#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
#line 1 "F:/Frank/src/vcpkg/buildtrees/tinyorm/x64-windows-dbg/CMakeFiles/TinyOrm.dir/cmake_pch.hxx"


#pragma external_header(push)


#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"






#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QDateTime"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"














































#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"












































#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"





#pragma once


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



























































































































































































































































































































































































































































































#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"







#pragma once






















#line 32 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

#line 34 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
#line 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"






    
    

#line 49 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
        
            
        

#line 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
    #line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 56 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"













#pragma once







































































































































#line 151 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"



#line 155 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"





























#line 185 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"


#line 188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"

#line 190 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"





#line 196 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"



#line 200 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






#line 207 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"











#line 219 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"








#line 228 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
#line 229 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"































































































































































































































































































































































































































































































#pragma region Input Buffer SAL 1 compatibility macros



























































































































































































































































































































































































































































































































































































































































































































































































#pragma endregion Input Buffer SAL 1 compatibility macros

















































































#line 1555 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






























#line 1586 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
























#line 1611 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"












#line 1624 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






































#line 1663 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"















































































































#line 1775 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






































































































#line 1878 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"








































































































































































#line 2047 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"





































































































#line 2149 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"



















































































































































































































#line 2361 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
extern "C" {




#line 2367 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"



































































































































































































































#line 2595 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    

    
    

#line 2634 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"









































































































































































































































#line 2868 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"









#line 2878 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"





#line 2884 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
    
#line 2886 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
#line 2887 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






#line 2894 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
#line 2895 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






#line 2902 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
#line 2903 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"











#line 2915 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"

































#line 2949 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"






















}
#line 2973 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"


















#pragma once


extern "C" {
#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"











































































































































































































































































#line 292 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"



#line 296 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"
















































#line 345 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"











































#line 389 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"


}
#line 393 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"

#line 395 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concurrencysal.h"
#pragma external_header(pop)
#line 2975 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sal.h"
#pragma external_header(pop)
#line 58 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"










#pragma once



#pragma pack(push, 8)



    


        
    #line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"
#line 25 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"




    


        
    #line 34 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"
#line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"



    
#line 40 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"




    
#line 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"

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


extern "C" {
#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"



#line 57 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"


    
    
        typedef unsigned __int64  uintptr_t;
    

#line 65 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"
#line 66 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"


    
    


        typedef char* va_list;
    #line 74 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"
#line 75 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"


    


#line 81 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"





#line 87 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"



#line 91 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"
    
    
#line 94 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"











#line 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"







#line 114 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"











#line 126 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"





#line 132 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"










#line 143 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"










#line 154 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"

    void __cdecl __va_start(va_list* , ...);

    
    



    

#line 165 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"


} 
#line 169 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vadefs.h"

#pragma warning(pop) 
#pragma pack(pop)
#pragma external_header(pop)
#line 59 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

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






    



    





















#line 95 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

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




    


        
    #line 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 107 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
















    

#line 126 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

#line 128 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
        
    #line 130 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 131 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    

#line 136 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
        
    #line 138 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"





#line 145 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
    
    
#line 148 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"




    
#line 154 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"








    


#line 166 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



#line 170 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
    
#line 172 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"




    
#line 178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
        
        
    

#line 186 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 187 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"






    typedef unsigned __int64 size_t;
    typedef __int64          ptrdiff_t;
    typedef __int64          intptr_t;




#line 201 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    typedef bool  __vcrt_bool;






#line 211 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



    
#line 216 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
#line 220 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
#line 224 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"








    
        
    

#line 237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 238 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    


#line 244 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



#line 248 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


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

        
    }


#line 260 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



#line 264 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    

#line 269 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
        
    #line 271 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


#line 274 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
        
    

#line 281 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 282 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
        
    

#line 289 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 290 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    

#line 295 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
        
    #line 297 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 298 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"





#line 304 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



#line 308 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



    


        
    

#line 318 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    


#line 325 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"









    
        
    

#line 339 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 340 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"









#line 350 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    


        




    #line 361 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 362 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"



#line 366 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    
        
    


#line 374 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 375 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


    void __cdecl __security_init_cookie(void);

    


#line 383 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"


#line 386 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
        void __cdecl __security_check_cookie(  uintptr_t _StackCookie);
        __declspec(noreturn) void __cdecl __report_gsfailure(  uintptr_t _StackCookie);
    #line 389 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#line 390 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

extern uintptr_t __security_cookie;


    
    
    
#line 398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"

} __pragma(pack(pop))

#pragma warning(pop) 

#line 404 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime.h"
#pragma external_header(pop)
#line 495 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#pragma once

























#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 45 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 51 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 57 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 63 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 69 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 75 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 81 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 87 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 93 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 99 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 105 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 111 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 117 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 123 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 141 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 147 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 153 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 159 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 165 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 171 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 177 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 183 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 189 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 195 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 201 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 207 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 213 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 219 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 225 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 231 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 243 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 249 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 255 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 261 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 267 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 273 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 279 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 285 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 291 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 297 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"






#line 304 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 310 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 316 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 322 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 328 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 334 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 340 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 346 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 352 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 358 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 364 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 370 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 376 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 382 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 388 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 394 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 400 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 406 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 412 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 418 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 424 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 430 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 436 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 442 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 448 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 454 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 460 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 466 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 472 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 478 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 490 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 496 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 502 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 508 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 514 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"






#line 521 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 527 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 533 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 539 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"






#line 546 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 552 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 558 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"







#line 566 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 572 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 578 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"





#line 584 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"



#line 588 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"

#line 590 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"
#line 591 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xkeycheck.h"
#pragma external_header(pop)
#line 496 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 502 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 504 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"














#line 519 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 521 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 522 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 526 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 530 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 538 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"













#line 552 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"













#line 566 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 577 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 581 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 583 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





















































































#line 669 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

































#line 703 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 705 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 713 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 721 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 729 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 734 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 740 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"














#line 755 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 760 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 762 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 767 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 769 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 773 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






































#line 812 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






















#line 835 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 836 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 843 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 844 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 856 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 860 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 861 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 869 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 871 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 872 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 883 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 885 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 889 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"


#line 892 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"


#line 895 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 896 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 900 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 904 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 914 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 921 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 926 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 928 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 933 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 935 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 942 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 947 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 952 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 956 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 961 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 966 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 974 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 979 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"














#line 994 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 1001 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1011 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1022 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1028 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"








#line 1037 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 1038 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"














#line 1054 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1065 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1078 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"












#line 1092 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1105 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"













#line 1120 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1133 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1145 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1157 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1170 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"















#line 1187 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1199 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
















#line 1217 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
















#line 1234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"















#line 1251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"












#line 1265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1277 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"












#line 1290 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"












#line 1304 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1317 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1327 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"











#line 1340 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1352 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1364 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1375 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1386 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1410 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"








#line 1420 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1422 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"








#line 1432 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1434 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1444 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1455 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
















#line 1473 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1475 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 1484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1486 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"










#line 1498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"








#line 1507 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1511 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1515 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1519 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1523 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1527 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1531 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1535 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1539 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1543 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1547 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 1554 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 1559 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1565 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1569 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 1574 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"































#line 1606 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"


























#line 1633 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1639 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"


















#line 1658 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 1665 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 1672 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1676 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1682 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1684 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 1685 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1689 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

















#line 1707 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



















#line 1727 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"









#line 1737 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1743 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"








#line 1752 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"













#line 1766 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1772 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






























































#line 1835 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 1842 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 1850 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1854 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1856 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"






#line 1863 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 1864 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1868 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1872 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"




#line 1877 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1879 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 1880 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1886 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1890 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1892 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1898 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





































#line 1936 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1940 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"



#line 1944 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"












#line 1957 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"


#line 1960 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"


#line 1963 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 1964 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1970 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"







#line 1978 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"





#line 1984 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"

#line 1986 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#line 1987 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals_core.h"
#pragma external_header(pop)
#line 10 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstddef"





#pragma once





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







#pragma once



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







#pragma once









    

















        
    #line 38 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 39 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


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


    
        
    

#line 50 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 51 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"

















    


        
    #line 73 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 74 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



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














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


    











        
    #line 111 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 112 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    


        
    #line 119 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 120 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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 136 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
        
    

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




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


    

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

#line 156 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



#line 161 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    
#line 163 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    


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





#line 175 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    
#line 177 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



    


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



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









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













    


        
    #line 219 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 220 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



#line 224 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    
#line 226 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



#line 230 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    
#line 232 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



#line 236 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    
#line 238 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    
        
    

#line 245 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 246 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"








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

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


    typedef bool  __crt_bool;






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










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








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



















    

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



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


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


 
  
   
  

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





#line 346 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 347 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


 

#line 352 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
   
 #line 354 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 355 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"







    __declspec(dllimport) void __cdecl _invalid_parameter(
          wchar_t const*,
          wchar_t const*,
          wchar_t const*,
                unsigned int,
                uintptr_t
        );
#line 370 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"

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

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


    
        

    













#line 401 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 402 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"












    


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



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


    


        


    #line 432 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 433 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"









    






        
    #line 451 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 452 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    


        
    #line 459 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 460 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



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













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















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





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



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


    

#line 510 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 511 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    


        


            
        #line 521 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    #line 522 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 523 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



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





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


    


        



    #line 543 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 544 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    
        
    



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

    
        
        
        
    



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

    
        
              
        

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



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

    
        
    



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

    
        
    



#line 591 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 592 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"


    
#line 596 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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 636 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



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


    


        typedef __time64_t time_t;
    #line 647 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 648 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"



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


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










    

        










        










        










        










        










        










        










        










        










        












        












        
















    














#line 827 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 828 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"












































































    













































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































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

        
        
        
        

        

            


            


            


            


            


            


            


            


            



            



            


            


            


            


            


            


            


            


            


            


            



            



            



            


            



            




            

            




            

            




            

            




            

            




            

            




            

            




            

            




            

        











































#line 2069 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
    #line 2070 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"
#line 2071 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt.h"

} __pragma(pack(pop))


#pragma warning(pop) 
#pragma external_header(pop)
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stddef.h"





    __declspec(dllimport) int* __cdecl _errno(void);
    

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

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









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

__declspec(dllimport) extern unsigned long  __cdecl __threadid(void);

__declspec(dllimport) extern uintptr_t __cdecl __threadhandle(void);



} __pragma(pack(pop))

#pragma warning(pop) 
#line 65 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stddef.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstddef"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 87 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();
}


 [[nodiscard]] constexpr bool is_constant_evaluated() noexcept {
    return __builtin_is_constant_evaluated();
}
#line 183 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 190 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 244 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtr1common"

}







#pragma warning(pop)
#pragma pack(pop)
#line 256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtr1common"
#line 257 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtr1common"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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; 
 using nullptr_t   = decltype(nullptr);


 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 93 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstddef"

}

using ::std:: max_align_t; 



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

#line 104 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstddef"
#line 105 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstddef"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdint"





#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdint.h"









    
    
        
    

#line 112 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdint.h"
#line 113 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdint.h"























#pragma warning(pop) 

#line 139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdint.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdint"
}



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

#line 97 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdint"
#line 98 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdint"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>

inline constexpr bool _Always_false = false;

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 _Identity {
    using type = _Ty;
};
template <class _Ty>
using _Identity_t [[msvc::known_semantics]] = typename _Identity<_Ty>::type;


 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 N4950 [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 249 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_convertible<_Ty&, volatile _Ty&> : true_type {};

template <class _Ty>
struct is_convertible<volatile _Ty&, volatile _Ty&> : true_type {};

template <class _Ty>
struct is_convertible<_Ty&, const volatile _Ty&> : true_type {};

template <class _Ty>
struct is_convertible<volatile _Ty&, const volatile _Ty&> : true_type {};

template <class _Ty>
inline constexpr bool is_convertible_v<_Ty&, volatile _Ty&> = true;

template <class _Ty>
inline constexpr bool is_convertible_v<volatile _Ty&, volatile _Ty&> = true;

template <class _Ty>
inline constexpr bool is_convertible_v<_Ty&, const volatile _Ty&> = true;

template <class _Ty>
inline constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
#line 356 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

 template <class _Ty>
struct is_enum : bool_constant<__is_enum(_Ty)> {}; 

 template <class _Ty>
inline constexpr bool is_enum_v = __is_enum(_Ty);







#line 370 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>;








#line 385 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"




#line 390 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

#line 392 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"








#line 401 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"






#line 408 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

























#line 434 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"


























#line 461 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"









































#line 503 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

template <class... _Types>
struct _Arg_types {}; 

template <class _Ty1>
struct _Arg_types<_Ty1> {
    using _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 suppress this warning.")]] = _Ty1;
};

template <class _Ty1, class _Ty2>
struct _Arg_types<_Ty1, _Ty2> {
    using _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 suppress this warning.")]]  = _Ty1;
    using _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 suppress this warning.")]] = _Ty2;
};

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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; 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; using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; };
















#line 564 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"





 template <class _Ty>
inline constexpr bool is_member_function_pointer_v = _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
#line 572 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 626 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 637 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress 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 suppress 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 693 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 709 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 751 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
#line 752 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _To, class _From>
struct _Is_assignable_no_precondition_check : bool_constant<__is_assignable_no_precondition_check(_To, _From)> {};



#line 810 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

 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 837 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 861 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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). "
        "To suppress this error, please define either "
        "(1) _ENABLE_EXTENDED_ALIGNED_STORAGE to confirm that you want a type with an extended alignment, or "
        "(2) _DISABLE_EXTENDED_ALIGNED_STORAGE to get the old non-conforming behavior.");
#line 1182 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
    using type = _Align_type<max_align_t, _Len>;
#line 1184 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Len, size_t _Align = alignof(max_align_t)>
struct  aligned_storage { 
    using type = _Aligned_storage_t<_Len, _Align>;
};

 template <size_t _Len, size_t _Align = alignof(max_align_t)>
using aligned_storage_t  = _Aligned_storage_t<_Len, _Align>;

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>;
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
 template <size_t _Len, class... _Types>
using aligned_union_t  = typename aligned_union<_Len, _Types...>::type;
__pragma(warning(pop))

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 1333 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Ty>
_Ty _Returns_exactly() noexcept; 


 template <class, class, template <class> class, template <class> class>
struct basic_common_reference {};

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 _Ty1, class _Ty2>
using _Cond_res_if_right = 
    decltype(false ? _Returns_exactly<_Ty1>() : _Returns_exactly<_Ty2>());

template <class _Ty>
using _Is_scalar_or_array = disjunction<is_scalar<_Ty>, is_array<_Ty>>;

template <class _Ty1, class _Ty2, class = void>
struct _Cond_res_workaround {};

template <class _Ty1, class _Ty2>
struct _Cond_res_workaround<_Ty1, _Ty2, void_t<_Cond_res_if_right<_Ty1, _Ty2>>> {
    using _Uty = remove_cvref_t<_Ty1>;
    using type = conditional_t<conjunction_v<is_same<_Uty, remove_cvref_t<_Ty2>>, _Is_scalar_or_array<_Uty>,
                                   disjunction<conjunction<is_lvalue_reference<_Ty1>, is_rvalue_reference<_Ty2>>,
                                       conjunction<is_rvalue_reference<_Ty1>, is_lvalue_reference<_Ty2>>>>,
        decay_t<_Copy_cv<remove_reference_t<_Ty1>, remove_reference_t<_Ty2>>>, _Cond_res_if_right<_Ty1, _Ty2>>;
};

template <class _Ty1, class _Ty2>
using _Cond_res = typename _Cond_res_workaround<_Ty1, _Ty2>::type;




#line 1444 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

 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, class = void>
struct _Common_reference2AX {};

template <class _Ty1, class _Ty2>
struct _Common_reference2AX<_Ty1&, _Ty2&, void_t<_LL_common_ref<_Ty1, _Ty2>>> {
    using type = _LL_common_ref<_Ty1, _Ty2>; 
};

template <class _Ty1, class _Ty2>
struct _Common_reference2AX<_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_reference2AX<_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_reference2AX<_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>
using _Common_ref_2AX_t = typename _Common_reference2AX<_Ty1, _Ty2>::type;

template <class _Ty1, class _Ty2>
struct _Common_reference2A<_Ty1, _Ty2,
    enable_if_t<is_convertible_v<add_pointer_t<_Ty1>, add_pointer_t<_Common_ref_2AX_t<_Ty1, _Ty2>>>
                && is_convertible_v<add_pointer_t<_Ty2>, add_pointer_t<_Common_ref_2AX_t<_Ty1, _Ty2>>>>> {
    using type = _Common_ref_2AX_t<_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 1548 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"


 template <class _Ty>
struct type_identity {
    using type = _Ty;
};
 template <class _Ty>
using type_identity_t = typename type_identity<_Ty>::type;
#line 1557 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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]] [[msvc::intrinsic]] constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept {
    return static_cast<_Ty&&>(_Arg);
}

 template <class _Ty>
[[nodiscard]] [[msvc::intrinsic]] 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]] [[msvc::intrinsic]] constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept {
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

 template <class _Ty>
[[nodiscard]] [[msvc::intrinsic]] 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>
[[nodiscard]] constexpr _Ty* addressof(_Ty& _Val) noexcept {
    return __builtin_addressof(_Val);
}

 template <class _Ty>
const _Ty* addressof(const _Ty&&) = delete;

#pragma warning(push)
#pragma warning(disable : 5215) 
#pragma warning(disable : 5216) 






template <class _Ty>
[[nodiscard]] _Ty _Fake_copy_init(_Ty) noexcept;









#pragma warning(pop)

 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_same_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>
                        || is_base_of_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, _Remove_cvref_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_same_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>
              || is_base_of_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, _Remove_cvref_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 {
        ;
        return (*static_cast<_Ty1&&>(_Arg1)).*_Obj;
    }
}

#pragma warning(push)
#pragma warning(disable : 4242) 
#pragma warning(disable : 4244) 
#pragma warning(disable : 4365) 

template <class _From, class _To, bool = is_convertible_v<_From, _To>, bool = is_void_v<_To>>
inline constexpr bool _Is_nothrow_convertible_v = noexcept(_Fake_copy_init<_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 1791 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

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(::std:: _Fake_copy_init<_To>(::std:: _Returns_exactly<_From>()))>>
    : true_type {};

template <class _From, class _To>
struct _Invoke_nothrow_convertible
    : bool_constant<noexcept(::std:: _Fake_copy_init<_To>(::std:: _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 1880 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1934 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1959 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
#line 1960 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

template <class _Ty>
struct _Function_args {}; 







template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)   > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)   > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const  > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const  > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile  > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile  > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile  > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile  > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile & > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile && > : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)   noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)   noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const  noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const  noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile  noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile  noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile  noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile  noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile & noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };    template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile && noexcept> : _Arg_types<_Types...> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };








template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) > { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) &> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) &&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const&&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile&&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile&&> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) & noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const& noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile& noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile& noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) && noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const&& noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile&& noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile&& noexcept> { using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret; };


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>> { 
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = typename _Ty::result_type;
};
__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> {
    
    using _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 suppress this warning.")]] = typename _Ty::argument_type;
};
__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> { 
    using _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 suppress this warning.")]]  = typename _Ty::first_argument_type;
    using _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 suppress this warning.")]] = typename _Ty::second_argument_type;
};
__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(::std:: _Refwrap_ctor_fun<_Ty>(::std:: declval<_Uty>()))>>
    : true_type {}; 

 template <class _Ty>
class reference_wrapper


#line 2037 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(::std:: _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 2077 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2123 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2212 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

namespace _Has_ADL_swap_detail {


#line 2217 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
    void swap();
#line 2219 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

    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 2235 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

template <class _Ty>
struct _Is_trivially_swappable : bool_constant<_Is_trivially_swappable_v<_Ty>> {
    
};


 template <class _From, class _To>
concept convertible_to =

    is_convertible_v<_From, _To>


#line 2249 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
    && requires { static_cast<_To>(::std:: declval<_From>()); };

template <class _RefWrap, class _Ty, class _RefWrapQ, class _TyQ>
concept _Ref_wrap_common_reference_exists_with = _Is_specialization_v<_RefWrap, reference_wrapper> && requires {
    typename common_reference_t<typename _RefWrap::type&, _TyQ>;
} && convertible_to<_RefWrapQ, common_reference_t<typename _RefWrap::type&, _TyQ>>;

template <class _RefWrap, class _Ty, template <class> class _RefWrapQual, template <class> class _TyQual>
    requires (_Ref_wrap_common_reference_exists_with<_RefWrap, _Ty, _RefWrapQual<_RefWrap>, _TyQual<_Ty>>
              && !_Ref_wrap_common_reference_exists_with<_Ty, _RefWrap, _TyQual<_Ty>, _RefWrapQual<_RefWrap>>)
struct basic_common_reference<_RefWrap, _Ty, _RefWrapQual, _TyQual> {
    using type = common_reference_t<typename _RefWrap::type&, _TyQual<_Ty>>;
};

template <class _Ty, class _RefWrap, template <class> class _TyQual, template <class> class _RefWrapQual>
    requires (_Ref_wrap_common_reference_exists_with<_RefWrap, _Ty, _RefWrapQual<_RefWrap>, _TyQual<_Ty>>
              && !_Ref_wrap_common_reference_exists_with<_Ty, _RefWrap, _TyQual<_Ty>, _RefWrapQual<_RefWrap>>)
struct basic_common_reference<_Ty, _RefWrap, _TyQual, _RefWrapQual> {
    using type = common_reference_t<typename _RefWrap::type&, _TyQual<_Ty>>;
};
#line 2270 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"


































template <class _Bitmask>
[[nodiscard]] constexpr bool _Bitmask_includes_any(_Bitmask _Left, _Bitmask _Elements) noexcept {
    return (_Left & _Elements) != _Bitmask{};
}

template <class _Bitmask>
[[nodiscard]] constexpr bool _Bitmask_includes_all(_Bitmask _Left, _Bitmask _Elements) noexcept {
    return (_Left & _Elements) == _Elements;
}




inline constexpr size_t _FNV_offset_basis = 14695981039346656037ULL;
inline constexpr size_t _FNV_prime        = 1099511628211ULL;



#line 2323 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { 
    using _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 suppress this warning.")]] = _Kty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[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> {
    using _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 suppress this warning.")]] = float;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;
    [[nodiscard]] size_t operator()(const float _Keyval) const noexcept {
        return _Hash_representation(_Keyval == 0.0F ? 0.0F : _Keyval); 
    }
};

template <>
struct hash<double> {
    using _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 suppress this warning.")]] = double;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;
    [[nodiscard]] size_t operator()(const double _Keyval) const noexcept {
        return _Hash_representation(_Keyval == 0.0 ? 0.0 : _Keyval); 
    }
};

template <>
struct hash<long double> {
    using _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 suppress this warning.")]] = long double;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;
    [[nodiscard]] size_t operator()(const long double _Keyval) const noexcept {
        return _Hash_representation(_Keyval == 0.0L ? 0.0L : _Keyval); 
    }
};

template <>
struct hash<nullptr_t> {
    using _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 suppress this warning.")]] = nullptr_t;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;
    [[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 _Ty = void>
struct less {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left < _Right)))  {
        return _Left < _Right;
    }
};

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 <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> {};



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 2587 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"

}








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

#line 2601 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
#line 2602 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\type_traits"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\initializer_list"
#line 70 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\initializer_list"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"



#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"





#pragma once









#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new.h"



    namespace std
    {
        struct nothrow_t {
            explicit nothrow_t() = default;
        };

        


            extern nothrow_t const nothrow;
        #line 44 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new.h"
    }
#line 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new.h"

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

    
    [[nodiscard]] [[msvc::constexpr]]      
    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 178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 193 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new.h"
#pragma warning(pop)



#pragma pack(pop)

} 
#line 201 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new.h"

#pragma warning(pop) 
#pragma external_header(pop)
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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>;












#line 211 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"

 template <class _Ty1, class _Ty2>
concept equality_comparable_with = equality_comparable<_Ty1> && equality_comparable<_Ty2>


#line 217 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"
    && common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
#line 219 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"
    && 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 301 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"
#line 302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"
#line 303 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\concepts"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"




#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
void _Literal_zero_is_expected();

struct _Literal_zero {
    template <class _Ty, enable_if_t<is_same_v<_Ty, int>, int> = 0>
    consteval _Literal_zero(_Ty _Zero) noexcept {
        
        if (_Zero != 0) {
            _Literal_zero_is_expected();
        }
    }
};

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>


#line 315 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    && common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
#line 317 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    && 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 {


#line 379 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    void strong_order();
#line 381 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"

    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  = _Bit_cast<_Uint_type>(_Left);
                const auto _Right_uint = _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 {


#line 475 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    void weak_order();
#line 477 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"

    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)); };

    


#line 491 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    void strong_order();
#line 493 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"

    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  = _Bit_cast<_Uint_type>(_Left);
                auto _Right_uint = _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 {


#line 601 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    void partial_order();
#line 603 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"

    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)); };

    
    



#line 619 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
    void weak_order();
    void strong_order();
#line 622 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"

    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 } -> _Boolean_testable;
    { _Left < _Right } -> _Boolean_testable;
};

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 } -> _Boolean_testable;
        { _Left < _Right } -> _Boolean_testable;
        { _Right < _Left } -> _Boolean_testable;
    };

    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 848 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
}



#pragma warning(pop)
#pragma pack(pop)
#line 855 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"

#line 857 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
#line 858 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\compare"
#pragma external_header(pop)
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"



#line 25 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _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 <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 _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> >
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) {
            swap(*_First1, *_First2); 
        }
    }
}


 template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> >


#line 128 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
}

 struct piecewise_construct_t { 
    explicit piecewise_construct_t() = default;
};

 inline constexpr piecewise_construct_t piecewise_construct{};

 template <class... _Types>
class tuple;

 template <class _Ty1, class _Ty2>
struct pair;

 template <class _Ty, size_t _Size>
class array;

 template <class _Tuple>
struct tuple_size;

 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>
using tuple_element_t = typename tuple_element<_Index, _Tuple>::type;

  template <size_t _Index, class... _Types>
[[nodiscard]] constexpr auto&& _Tuple_get(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;

 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 _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 _Ty1, class _Ty2>
concept _Different_from = !same_as<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>;

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>
inline constexpr bool _Is_subrange_v = false;


















#line 220 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
#line 221 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

 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() {}

    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 245 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
    template <class _Other1, class _Other2,
#line 247 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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)) {
    }

    pair(const pair&) = default;
    pair(pair&&)      = default;








#line 265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    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) {}

    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 307 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    template <class _Tuple1, class _Tuple2, size_t... _Indices1, size_t... _Indices2>
    constexpr pair(_Tuple1& _Val1, _Tuple2& _Val2, index_sequence<_Indices1...>, index_sequence<_Indices2...>)
        : first(_Tuple_get<_Indices1>(::std:: move(_Val1))...), second(_Tuple_get<_Indices2>(::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;
    }













#line 342 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    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;
    }













#line 367 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    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;
    }













#line 393 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    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;
    }







































#line 444 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    constexpr void swap(pair& _Right) noexcept(
        _Is_nothrow_swappable<_Ty1>::value&& _Is_nothrow_swappable<_Ty2>::value) {
        using ::std:: swap;
        if (this != ::std:: addressof(_Right)) {
            swap(first, _Right.first); 
            swap(second, _Right.second); 
        }
    }











#line 465 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

    _Ty1 first; 
    _Ty2 second; 
};


template <class _Ty1, class _Ty2>
pair(_Ty1, _Ty2) -> pair<_Ty1, _Ty2>;
#line 474 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
}








#line 489 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

 template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
[[nodiscard]] constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
    return _Left.first == _Right.first && _Left.second == _Right.second;
}


 template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
[[nodiscard]] constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1, _Uty1>,
    _Synth_three_way_result<_Ty2, _Uty2>>
    operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
    if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
        return _Result;
    }
    return _Synth_three_way{}(_Left.second, _Right.second);
}



























#line 533 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
















#line 550 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress 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 suppress 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 suppress 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 suppress 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 suppress this warning.")]] [[nodiscard]] bool operator>=(const _Ty& _Left, const _Ty& _Right) {
        return !(_Left < _Right);
    }
} 

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 suppress 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 suppress this warning.")]] tuple_size<const volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; 

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 suppress 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 suppress 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 <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 <size_t _Idx, class _Ty1, class _Ty2>
[[nodiscard]] constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
    
    if constexpr (_Idx == 0) {
        return _Pr.first;
    } else {
        return _Pr.second;
    }
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr _Ty1& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
    
    return _Pr.first;
}

 template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr _Ty2& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
    
    return _Pr.second;
}

 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 {
    
    if constexpr (_Idx == 0) {
        return _Pr.first;
    } else {
        return _Pr.second;
    }
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr const _Ty1& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
    
    return _Pr.first;
}

 template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr const _Ty2& get(const pair<_Ty1, _Ty2>& _Pr) 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 {
    
    if constexpr (_Idx == 0) {
        return ::std:: forward<_Ty1>(_Pr.first);
    } else {
        return ::std:: forward<_Ty2>(_Pr.second);
    }
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr _Ty1&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
    
    return ::std:: forward<_Ty1>(_Pr.first);
}

 template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr _Ty2&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
    
    return ::std:: forward<_Ty2>(_Pr.second);
}

 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 {
    
    if constexpr (_Idx == 0) {
        return ::std:: forward<const _Ty1>(_Pr.first);
    } else {
        return ::std:: forward<const _Ty2>(_Pr.second);
    }
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr const _Ty1&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
    
    return ::std:: forward<const _Ty1>(_Pr.first);
}

 template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr const _Ty2&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
    
    return ::std:: forward<const _Ty2>(_Pr.second);
}

 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 796 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 804 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

                                              char8_t,
#line 807 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}


template <class _Ty>
using _With_reference = _Ty&;

template <class _Ty>
concept _Can_reference = requires { typename _With_reference<_Ty>; };






#line 916 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
#line 917 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"





































#line 955 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"







#line 963 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"

}








#pragma warning(pop)
#pragma pack(pop)
#line 976 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
#line 977 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\utility"
#pragma external_header(pop)
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\assert.h"









#line 11 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {





#line 24 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\assert.h"









    __declspec(dllimport) void __cdecl _wassert(
          wchar_t const* _Message,
          wchar_t const* _File,
            unsigned       _Line
        );

    




#line 45 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\assert.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"













#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qconfig.h"



















































#pragma external_header(pop)
#line 67 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtcore-config.h"
















































#pragma external_header(pop)
#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"








#line 78 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"















#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"






#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"


















































































































#line 116 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"


#line 119 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"


#line 122 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"

#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"





























































#line 186 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"









#line 196 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"
#line 197 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"





#line 203 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"




































































































#line 304 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsystemdetection.h"
#pragma external_header(pop)
#line 104 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"








































































#line 74 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"

#line 76 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"


#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"

#line 81 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"






































































































#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"


























#line 211 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"




































































































































#line 344 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"






















#line 367 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"















#line 383 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"

#line 385 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"



#line 389 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"













#line 403 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qprocessordetection.h"
#pragma external_header(pop)
#line 105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"




















































































#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"



















#line 106 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"












#line 119 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"











































































































































































































































































































































































































#line 515 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"









#line 525 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 528 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 531 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"








#line 540 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"




























































#line 601 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#line 602 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"











































































#line 678 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

































































































































































#line 840 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"






#line 847 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"







































































































#line 951 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"



       


       








       








       



       








       

















#line 1007 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1010 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#line 1011 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#line 1012 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"



#line 1016 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"




































#line 1053 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"















#line 1069 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"






#line 1076 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"






#line 1083 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#line 1084 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"








#line 1093 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"





#line 1099 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"





#line 1105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"




#line 1110 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"












#line 1123 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"





#line 1129 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"











#line 1141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"







#line 1149 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"





#line 1155 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"




#line 1160 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"





#line 1166 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"











#line 1178 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#line 1179 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"










#line 1190 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1193 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"








#line 1202 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"








#line 1211 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

















#line 1229 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1235 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"









#line 1245 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1248 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1251 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1254 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"















#line 1273 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
















#line 1290 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"








#line 1299 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

































#line 1333 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"







#line 1341 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"














#line 1356 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

















#line 1374 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

#line 1376 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

#line 1378 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#line 1379 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"





















#line 1401 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"


#line 1404 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"



#line 1408 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"

#line 1410 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcompilerdetection.h"
#pragma external_header(pop)
#line 106 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



#line 110 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 113 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

























#line 139 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"





#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdlib"





#pragma once





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










#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_math.h"
    #line 47 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_math.h"
#line 48 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_math.h"










#line 59 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_math.h"















    
        extern double const _HUGE;
    

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


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











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












































































void __cdecl _fperrraise(  int _Except);

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

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

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

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

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

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

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

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

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

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

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

  __declspec(dllimport) double __cdecl _dsin(  double _X,   unsigned int _Qoff);
  __declspec(dllimport) long double __cdecl _ldsin(  long double _X,   unsigned int _Qoff);
  __declspec(dllimport) 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 465 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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);

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

    int __cdecl _matherr(  struct _exception* _Except);

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

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

    



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

    

          __declspec(dllimport) float __cdecl _logbf(  float _X);
          __declspec(dllimport) float __cdecl _nextafterf(  float _X,   float _Y);
          __declspec(dllimport) int   __cdecl _finitef(  float _X);
          __declspec(dllimport) int   __cdecl _isnanf(  float _X);
          __declspec(dllimport) int   __cdecl _fpclassf(  float _X);

          __declspec(dllimport) int   __cdecl _set_FMA3_enable(  int _Flag);
          __declspec(dllimport) int   __cdecl _get_FMA3_enable(void);

    




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



    

          __declspec(dllimport) float __cdecl acosf(  float _X);
          __declspec(dllimport) float __cdecl asinf(  float _X);
          __declspec(dllimport) float __cdecl atan2f(  float _Y,   float _X);
          __declspec(dllimport) float __cdecl atanf(  float _X);
          __declspec(dllimport) float __cdecl ceilf(  float _X);
          __declspec(dllimport) float __cdecl cosf(  float _X);
          __declspec(dllimport) float __cdecl coshf(  float _X);
          __declspec(dllimport) float __cdecl expf(  float _X);

    









































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

    







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

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

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

    

          __declspec(dllimport) float __cdecl floorf(  float _X);
          __declspec(dllimport) float __cdecl fmodf(  float _X,   float _Y);

    











#line 703 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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);
    }

    

          __declspec(dllimport) float  __cdecl log10f(  float _X);
          __declspec(dllimport) float  __cdecl logf(  float _X);
          __declspec(dllimport) float  __cdecl modff(  float _X,   float *_Y);
          __declspec(dllimport) float  __cdecl powf(  float _X,   float _Y);
          __declspec(dllimport) float  __cdecl sinf(  float _X);
          __declspec(dllimport) float  __cdecl sinhf(  float _X);
          __declspec(dllimport) float  __cdecl sqrtf(  float _X);
          __declspec(dllimport) float  __cdecl tanf(  float _X);
          __declspec(dllimport) float  __cdecl tanhf(  float _X);

    

















































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

      __declspec(dllimport) long double __cdecl acoshl(  long double _X);

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

      __declspec(dllimport) 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);
    }

      __declspec(dllimport) long double __cdecl atanhl(  long double _X);

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

      __declspec(dllimport) 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);
    }

      __declspec(dllimport) 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);
    }

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

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

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

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

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

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

      __declspec(dllimport) long double __cdecl fmal(  long double _X,   long double _Y,   long double _Z);
      __declspec(dllimport) long double __cdecl fmaxl(  long double _X,   long double _Y);
      __declspec(dllimport) 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);
    }

      __declspec(dllimport) 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);
    }

      __declspec(dllimport) long double __cdecl lgammal(  long double _X);
      __declspec(dllimport) long long __cdecl llrintl(  long double _X);
      __declspec(dllimport) 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);
    }

      __declspec(dllimport) long double __cdecl log1pl(  long double _X);
      __declspec(dllimport) long double __cdecl log2l(  long double _X);
      __declspec(dllimport) long double __cdecl logbl(  long double _X);
      __declspec(dllimport) long __cdecl lrintl(  long double _X);
      __declspec(dllimport) 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;
    }

      __declspec(dllimport) long double __cdecl nanl(  char const* _X);
      __declspec(dllimport) long double __cdecl nearbyintl(  long double _X);
      __declspec(dllimport) long double __cdecl nextafterl(  long double _X,   long double _Y);
      __declspec(dllimport) 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);
    }

      __declspec(dllimport) long double __cdecl remainderl(  long double _X,   long double _Y);
      __declspec(dllimport) long double __cdecl remquol(  long double _X,   long double _Y,   int* _Z);
      __declspec(dllimport) long double __cdecl rintl(  long double _X);
      __declspec(dllimport) long double __cdecl roundl(  long double _X);
      __declspec(dllimport) long double __cdecl scalblnl(  long double _X,   long _Y);
      __declspec(dllimport) 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);
    }

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

    



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



    
    
    
    
    
    

    

    
        
            extern double HUGE;
        

#line 988 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))   __declspec(dllimport) 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."))   __declspec(dllimport) 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."))   __declspec(dllimport) 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."))   __declspec(dllimport) 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."))   __declspec(dllimport) 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."))   __declspec(dllimport) double __cdecl yn(  int _X,   double _Y);
    #line 996 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_math.h"

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

} __pragma(pack(pop))

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




#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdlib"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"







#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_malloc.h"

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

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

 
__declspec(dllimport) int __cdecl _callnewh(
      size_t _Size
    );

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

__declspec(dllimport)
void __cdecl _free_base(
        void* _Block
    );

__declspec(dllimport) 
void __cdecl free(
        void* _Block
    );

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

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

 
__declspec(dllimport)
size_t __cdecl _msize_base(
      void* _Block
    ) noexcept;

 
__declspec(dllimport) 
size_t __cdecl _msize(
      void* _Block
    );

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

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

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

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

__declspec(dllimport)
void __cdecl _aligned_free(
        void* _Block
    );

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

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

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

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

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

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

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


















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



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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*);




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

    __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_search.h"



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

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

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

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

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

 
__declspec(dllimport) 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.22621.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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_search.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 15 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {


































     
    
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _itow( int _Value,   wchar_t *_Buffer,  int _Radix);
#line 74 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdlib.h"

     
    
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _ltow( long _Value,   wchar_t *_Buffer,  int _Radix);
#line 97 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdlib.h"

    
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _ultow( unsigned long _Value,   wchar_t *_Buffer,  int _Radix);
#line 119 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdlib.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

     
    __declspec(dllimport) double __cdecl _wtof(
          wchar_t const* _String
        );

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

     
    __declspec(dllimport) int __cdecl _wtoi(
          wchar_t const* _String
        );

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

     
    __declspec(dllimport) long __cdecl _wtol(
          wchar_t const* _String
        );

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

     
    __declspec(dllimport) long long __cdecl _wtoll(
          wchar_t const* _String
        );

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

    
    __declspec(dllimport) 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."))
    __declspec(dllimport) wchar_t* __cdecl _i64tow(
                            __int64  _Value,
            wchar_t* _Buffer,
                            int      _Radix
        );

    
    __declspec(dllimport) 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."))
    __declspec(dllimport) wchar_t* __cdecl _ui64tow(
                            unsigned __int64 _Value,
            wchar_t*         _Buffer,
                            int              _Radix
        );

     
    __declspec(dllimport) __int64 __cdecl _wtoi64(
          wchar_t const* _String
        );

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

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

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

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

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

    
    

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

    

    
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstdlib.h"

    __declspec(dllimport) 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."))
    __declspec(dllimport) void __cdecl _wsplitpath(
                            wchar_t const* _FullPath,
            wchar_t*       _Drive,
            wchar_t*       _Dir,
            wchar_t*       _Filename,
            wchar_t*       _Ext
        );

    __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstdlib.h"

        
        

        
        __declspec(dllimport) 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."))
        __declspec(dllimport) wchar_t* __cdecl _wgetenv(
              wchar_t const* _VarName
            );

         
        
        __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstdlib.h"

         
        __declspec(dllimport) int __cdecl _wputenv(
              wchar_t const* _EnvString
            );

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

        __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstdlib.h"

        __declspec(dllimport) int __cdecl _wsystem(
              wchar_t const* _Command
            );

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



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 16 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits.h"







#pragma once




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

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







    
    



#line 30 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits.h"









































    
        
    #line 74 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits.h"
#line 75 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 17 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdlib.h"









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













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





__declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"


    
    
#line 87 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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);

    
    __declspec(dllimport) _invalid_parameter_handler __cdecl _set_invalid_parameter_handler(
          _invalid_parameter_handler _Handler
        );

    __declspec(dllimport) _invalid_parameter_handler __cdecl _get_invalid_parameter_handler(void);

    __declspec(dllimport) _invalid_parameter_handler __cdecl _set_thread_local_invalid_parameter_handler(
          _invalid_parameter_handler _Handler
        );

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












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









 __declspec(dllimport) int __cdecl _set_error_mode(  int _Mode);




    __declspec(dllimport) int* __cdecl _errno(void);
    

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

    __declspec(dllimport) unsigned long* __cdecl __doserrno(void);
    

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

    
    __declspec(dllimport) __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(dllimport) __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);
    

    __declspec(dllimport) void __cdecl perror(  char const* _ErrMsg);
#line 238 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.")) __declspec(dllimport) 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.")) __declspec(dllimport) 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.")) __declspec(dllimport) int*      __cdecl __p__fmode  (void);








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

 
__declspec(dllimport) errno_t __cdecl _get_pgmptr (  char**    _Value);

 
__declspec(dllimport) errno_t __cdecl _get_wpgmptr(  wchar_t** _Value);

__declspec(dllimport) errno_t __cdecl _set_fmode  (               int       _Mode );

__declspec(dllimport) 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);

  __declspec(dllimport) div_t   __cdecl div  (  int       _Numerator,   int       _Denominator);
  __declspec(dllimport) ldiv_t  __cdecl ldiv (  long      _Numerator,   long      _Denominator);
  __declspec(dllimport) 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)






__declspec(dllimport) void __cdecl srand(  unsigned int _Seed);

  __declspec(dllimport) int __cdecl rand(void);



#line 357 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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)








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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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








 

__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _itoa( int _Value,   char *_Buffer,  int _Radix);
#line 647 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"

 

__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _ltoa( long _Value,   char *_Buffer,  int _Radix);
#line 670 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"

 

__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _ultoa( unsigned long _Value,   char *_Buffer,  int _Radix);
#line 693 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"

 

__declspec(dllimport) 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."))
__declspec(dllimport) char* __cdecl _i64toa(
                        __int64 _Value,
        char*   _Buffer,
                        int     _Radix
    );

 

__declspec(dllimport) 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."))
__declspec(dllimport) char* __cdecl _ui64toa(
                        unsigned __int64 _Value,
        char*            _Buffer,
                        int              _Radix
    );













 

__declspec(dllimport) 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.22621.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."))
__declspec(dllimport) char* __cdecl _ecvt(
       double _Value,
       int    _DigitCount,
      int*   _PtDec,
      int*   _PtSign
    );

 

__declspec(dllimport) 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.22621.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."))
__declspec(dllimport) char* __cdecl _fcvt(
       double _Value,
       int    _FractionalDigitCount,
      int*   _PtDec,
      int*   _PtSign
    );

 
__declspec(dllimport) 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.22621.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."))
__declspec(dllimport) char* __cdecl _gcvt(
                        double _Value,
                        int    _DigitCount,
        char*  _Buffer
    );











    

#line 833 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"
        
    #line 835 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"

    


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

     
    __declspec(dllimport) int __cdecl ___mb_cur_max_func(void);

     
    __declspec(dllimport) int __cdecl ___mb_cur_max_l_func(_locale_t _Locale);
#line 848 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"



 
__declspec(dllimport) int __cdecl mblen(
        char const* _Ch,
                                             size_t      _MaxCount
    );

 
__declspec(dllimport) int __cdecl _mblen_l(
        char const* _Ch,
                                             size_t      _MaxCount,
                                         _locale_t   _Locale
    );

 
 
__declspec(dllimport) size_t __cdecl _mbstrlen(
      char const* _String
    );

 
 
__declspec(dllimport) size_t __cdecl _mbstrlen_l(
        char const* _String,
      _locale_t   _Locale
    );

 
 
__declspec(dllimport) size_t __cdecl _mbstrnlen(
      char const* _String,
        size_t      _MaxCount
    );

 
 
__declspec(dllimport) size_t __cdecl _mbstrnlen_l(
        char const* _String,
          size_t      _MaxCount,
      _locale_t   _Locale
    );

 
__declspec(dllimport) int __cdecl mbtowc(
                      wchar_t*    _DstCh,
      char const* _SrcCh,
                                      size_t      _SrcSizeInBytes
    );

 
__declspec(dllimport) int __cdecl _mbtowc_l(
                      wchar_t*    _DstCh,
      char const* _SrcCh,
                                      size_t      _SrcSizeInBytes,
                                  _locale_t   _Locale
    );


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.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."))
__declspec(dllimport) 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."))
__declspec(dllimport) int __cdecl _wctomb_l(
        char*     _MbCh,
                          wchar_t   _WCh,
                      _locale_t _Locale
    );



    
    __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"


__declspec(dllimport) errno_t __cdecl _wctomb_s_l(
                             int*     _SizeConverted,
      char*     _MbCh,
                                  size_t    _SizeInBytes,
                                  wchar_t   _WCh,
                              _locale_t _Locale);


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"




















 
 
__declspec(dllimport) __declspec(allocator) char* __cdecl _fullpath(
      char*       _Buffer,
                                char const* _Path,
                                  size_t      _BufferCount
    );




__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.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."))
__declspec(dllimport) void __cdecl _splitpath(
                        char const* _FullPath,
        char*       _Drive,
        char*       _Dir,
        char*       _Filename,
        char*       _Ext
    );


__declspec(dllimport) 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); } }




 
__declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"




__declspec(dllimport) int*       __cdecl __p___argc (void);
__declspec(dllimport) char***    __cdecl __p___argv (void);
__declspec(dllimport) wchar_t*** __cdecl __p___wargv(void);






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

__declspec(dllimport) char***    __cdecl __p__environ (void);
__declspec(dllimport) wchar_t*** __cdecl __p__wenviron(void);


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







    
    
#line 1174 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"

    


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

    
    __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"

    __declspec(dllimport) int __cdecl system(
          char const* _Command
        );

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

     
    __declspec(dllimport) int __cdecl _putenv(
          char const* _EnvString
        );

    
    __declspec(dllimport) errno_t __cdecl _putenv_s(
          char const* _Name,
          char const* _Value
        );

    #pragma warning(pop)

    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) void __cdecl _searchenv( char const* _Filename,  char const* _VarName,   char *_Buffer);
#line 1253 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) void __cdecl _sleep(
          unsigned long _Duration
        );

#line 1272 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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.22621.0\\ucrt\\stdlib.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 1363 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdlib.h"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

 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 90 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdlib"
#line 91 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdlib"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cfloat"





#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\float.h"
    #line 33 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"
#line 34 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"



















    






        
    #line 62 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"
#line 63 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"
























































































































































#line 216 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"

    

#line 220 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"











__declspec(dllimport) 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."))
__declspec(dllimport) unsigned int __cdecl _controlfp(
      unsigned int _NewValue,
      unsigned int _Mask
    );

#pragma warning(pop)


__declspec(dllimport) void __cdecl _set_controlfp(
      unsigned int _NewValue,
      unsigned int _Mask
    );


__declspec(dllimport) errno_t __cdecl _controlfp_s(
      unsigned int* _CurrentState,
           unsigned int  _NewValue,
           unsigned int  _Mask
    );


__declspec(dllimport) unsigned int __cdecl _statusfp(void);


__declspec(dllimport) void __cdecl _fpreset(void);















__declspec(dllimport) unsigned int __cdecl _control87(
      unsigned int _NewValue,
      unsigned int _Mask
    );












 
__declspec(dllimport) int* __cdecl __fpecode(void);



 
__declspec(dllimport) int __cdecl __fpe_flt_rounds(void);












  __declspec(dllimport) double __cdecl _copysign(  double _Number,   double _Sign);
  __declspec(dllimport) double __cdecl _chgsign(  double _X);
  __declspec(dllimport) double __cdecl _scalb(  double _X,   long _Y);
  __declspec(dllimport) double __cdecl _logb(  double _X);
  __declspec(dllimport) double __cdecl _nextafter(  double _X,   double _Y);
  __declspec(dllimport) int    __cdecl _finite(  double _X);
  __declspec(dllimport) int    __cdecl _isnan(  double _X);
  __declspec(dllimport) int    __cdecl _fpclass(  double _X);


      __declspec(dllimport) float __cdecl _scalbf(  float _X,   long _Y);
#line 324 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"










    
    
    

    
    __declspec(dllimport) void __cdecl fpreset(void);

    
    

    
    

    
    
    

    
    
    
    
    
    
    

    
    
    

    
    
    
    
    

    
    
    
    

    

    
    
    
    
    
    

    
    
    
    

    
    
    
    
    
    

    
    
    
    

    

#line 403 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 410 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\float.h"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cfloat"
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cfloat"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\climits"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\climits"
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\climits"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cwchar"





#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdio"





#pragma once





#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"







#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"









#pragma once


#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_stdio_config.h"




#line 26 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"
    
#line 28 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"


    

#line 33 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"
        
    

#line 37 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"
#line 38 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"














    








#line 62 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"




#line 67 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_stdio_config.h"
    #line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"
#line 76 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"






#line 83 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_stdio_config.h"



#line 109 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_stdio_config.h"




















} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

__declspec(dllimport) FILE* __cdecl __acrt_iob_func(unsigned _Ix);










    
    
    
    
    
    
    __declspec(dllimport) wint_t __cdecl fgetwc(
          FILE* _Stream
        );

    
    __declspec(dllimport) wint_t __cdecl _fgetwchar(void);

    
    __declspec(dllimport) wint_t __cdecl fputwc(
             wchar_t _Character,
          FILE*   _Stream);

    
    __declspec(dllimport) wint_t __cdecl _fputwchar(
          wchar_t _Character
        );

     
    __declspec(dllimport) wint_t __cdecl getwc(
          FILE* _Stream
        );

     
    __declspec(dllimport) wint_t __cdecl getwchar(void);


    
     
    __declspec(dllimport) wchar_t* __cdecl fgetws(
          wchar_t* _Buffer,
                                  int      _BufferCount,
                               FILE*    _Stream
        );

    
    __declspec(dllimport) int __cdecl fputws(
           wchar_t const* _Buffer,
          FILE*          _Stream
        );

    
     
    __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstdio.h"

    
    __declspec(dllimport) wint_t __cdecl putwc(
             wchar_t _Character,
          FILE*   _Stream
        );

    
    __declspec(dllimport) wint_t __cdecl putwchar(
          wchar_t _Character
        );

    
    __declspec(dllimport) int __cdecl _putws(
          wchar_t const* _Buffer
        );

    
    __declspec(dllimport) wint_t __cdecl ungetwc(
             wint_t _Character,
          FILE*  _Stream
        );

     
    __declspec(dllimport) 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."))
    __declspec(dllimport) FILE* __cdecl _wfopen(
          wchar_t const* _FileName,
          wchar_t const* _Mode
        );

    
    __declspec(dllimport) 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."))
    __declspec(dllimport) FILE* __cdecl _wfreopen(
           wchar_t const* _FileName,
           wchar_t const* _Mode,
          FILE*          _OldStream
        );

    
    __declspec(dllimport) errno_t __cdecl _wfreopen_s(
          FILE**         _Stream,
                             wchar_t const* _FileName,
                             wchar_t const* _Mode,
                            FILE*          _OldStream
        );

     
    __declspec(dllimport) FILE* __cdecl _wfsopen(
          wchar_t const* _FileName,
          wchar_t const* _Mode,
            int            _ShFlag
        );

    __declspec(dllimport) void __cdecl _wperror(
          wchar_t const* _ErrorMessage
        );

    

         
        __declspec(dllimport) FILE* __cdecl _wpopen(
              wchar_t const* _Command,
              wchar_t const* _Mode
            );

    #line 181 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"

    __declspec(dllimport) int __cdecl _wremove(
          wchar_t const* _FileName
        );

    
    

     
    __declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wtempnam(
          wchar_t const* _Directory,
          wchar_t const* _FilePrefix
        );

    

     
    
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport)  wchar_t* __cdecl _wtmpnam(  wchar_t *_Buffer);
#line 215 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"



    
    
    
    
    
    
    __declspec(dllimport) wint_t __cdecl _fgetwc_nolock(
          FILE* _Stream
        );

    
    __declspec(dllimport) wint_t __cdecl _fputwc_nolock(
             wchar_t _Character,
          FILE*   _Stream
        );

    
    __declspec(dllimport) wint_t __cdecl _getwc_nolock(
          FILE* _Stream
        );

    
    __declspec(dllimport) wint_t __cdecl _putwc_nolock(
             wchar_t _Character,
          FILE*   _Stream
        );

    
    __declspec(dllimport) wint_t __cdecl _ungetwc_nolock(
             wint_t _Character,
          FILE*  _Stream
        );

    



#line 256 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"



    
    





    
    
    
    
    
    
    __declspec(dllimport) int __cdecl __stdio_common_vfwprintf(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __declspec(dllimport) int __cdecl __stdio_common_vfwprintf_s(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 326 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 359 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 446 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 551 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 662 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.0\\ucrt\\corecrt_wstdio.h"


    
    
    
    
    
    
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwscanf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 743 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 778 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 835 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 913 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 987 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"



    
    
    
    
    
    
        



    

#line 1003 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"

     
    
    __declspec(dllimport) int __cdecl __stdio_common_vswprintf(
                                             unsigned __int64 _Options,
                 wchar_t*         _Buffer,
                                             size_t           _BufferCount,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
    
    __declspec(dllimport) 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
        );

     
    
    __declspec(dllimport) 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
        );

     
    
    __declspec(dllimport) 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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 1283 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vscwprintf_l(_Format, 0, _ArgList);
    }
    #line 1361 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vscwprintf_p_l(_Format, 0, _ArgList);
    }
    #line 1394 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 1534 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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)(__va_start(&_ArgList, _Format))))); return vswprintf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1541 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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)(__va_start(&_ArgList, _Format))))); return _vsnwprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 1719 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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)(__va_start(&_ArgList, _Format)))));
                _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)(__va_start(&_ArgList, _Locale)))));
                _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.22621.0\\ucrt\\corecrt_wstdio.h"

        #pragma warning(pop)
    #line 1856 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"

    




#line 1863 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"


    
    
    
    
    
     
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswscanf_l(_Buffer, _Format, 0, _ArgList);
    }
    #line 1912 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 1949 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\corecrt_wstdio.h"

    #line 2077 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.0\\ucrt\\corecrt_wstdio.h"

    


#line 2168 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstdio.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"















    
    
#line 71 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"


typedef __int64 fpos_t;





    
    __declspec(dllimport) errno_t __cdecl _get_stream_buffer_pointers(
               FILE*   _Stream,
          char*** _Base,
          char*** _Pointer,
          int**   _Count
        );


    
    
    
    
    
    

        
        __declspec(dllimport) errno_t __cdecl clearerr_s(
              FILE* _Stream
            );

        
         
        __declspec(dllimport) errno_t __cdecl fopen_s(
              FILE**      _Stream,
                                     char const* _FileName,
                                     char const* _Mode
            );

        
         
        __declspec(dllimport) size_t __cdecl fread_s(
                void*  _Buffer,
                                    size_t _BufferSize,
                                                                            size_t _ElementSize,
                                                                            size_t _ElementCount,
                                                                         FILE*  _Stream
            );

        
        __declspec(dllimport) errno_t __cdecl freopen_s(
              FILE**      _Stream,
                                 char const* _FileName,
                                 char const* _Mode,
                                FILE*       _OldStream
            );

         
        __declspec(dllimport) char* __cdecl gets_s(
              char*   _Buffer,
                               rsize_t _Size
            );

        
        __declspec(dllimport) errno_t __cdecl tmpfile_s(
                FILE** _Stream
            );

         
        
        __declspec(dllimport) errno_t __cdecl tmpnam_s(
              char*   _Buffer,
                               rsize_t _Size
            );

    #line 145 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    __declspec(dllimport) void __cdecl clearerr(
          FILE* _Stream
        );

     
    
    __declspec(dllimport) int __cdecl fclose(
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl _fcloseall(void);

     
    __declspec(dllimport) FILE* __cdecl _fdopen(
            int         _FileHandle,
          char const* _Mode
        );

     
    __declspec(dllimport) int __cdecl feof(
          FILE* _Stream
        );

     
    __declspec(dllimport) int __cdecl ferror(
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl fflush(
          FILE* _Stream
        );

     
    
    __declspec(dllimport) int __cdecl fgetc(
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl _fgetchar(void);

     
    
    __declspec(dllimport) int __cdecl fgetpos(
          FILE*   _Stream,
            fpos_t* _Position
        );

     
    
    __declspec(dllimport) char* __cdecl fgets(
          char* _Buffer,
                               int   _MaxCount,
                            FILE* _Stream
        );

     
    __declspec(dllimport) int __cdecl _fileno(
          FILE* _Stream
        );

    
    __declspec(dllimport) 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."))
    __declspec(dllimport) FILE* __cdecl fopen(
          char const* _FileName,
          char const* _Mode
        );


     
    
    __declspec(dllimport) int __cdecl fputc(
             int   _Character,
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl _fputchar(
          int _Character
        );

     
    
    __declspec(dllimport) int __cdecl fputs(
           char const* _Buffer,
          FILE*       _Stream
        );

    
    __declspec(dllimport) 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."))
    __declspec(dllimport) FILE* __cdecl freopen(
           char const* _FileName,
           char const* _Mode,
          FILE*       _Stream
        );

     
    __declspec(dllimport) FILE* __cdecl _fsopen(
          char const* _FileName,
          char const* _Mode,
            int         _ShFlag
        );

     
    
    __declspec(dllimport) int __cdecl fsetpos(
          FILE*         _Stream,
             fpos_t const* _Position
        );

     
    
    __declspec(dllimport) int __cdecl fseek(
          FILE* _Stream,
             long  _Offset,
             int   _Origin
        );

     
    
    __declspec(dllimport) int __cdecl _fseeki64(
          FILE*   _Stream,
             __int64 _Offset,
             int     _Origin
        );

     
     
    __declspec(dllimport) long __cdecl ftell(
          FILE* _Stream
        );

     
     
    __declspec(dllimport) __int64 __cdecl _ftelli64(
          FILE* _Stream
        );

    
    __declspec(dllimport) size_t __cdecl fwrite(
          void const* _Buffer,
                                                    size_t      _ElementSize,
                                                    size_t      _ElementCount,
                                                 FILE*       _Stream
        );

     
     
    __declspec(dllimport) int __cdecl getc(
          FILE* _Stream
        );

     
    __declspec(dllimport) int __cdecl getchar(void);

     
    __declspec(dllimport) 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.22621.0\\ucrt\\stdio.h"

     
    __declspec(dllimport) int __cdecl _getw(
          FILE* _Stream
        );

    __declspec(dllimport) void __cdecl perror(
          char const* _ErrorMessage
        );

    

         
        
        __declspec(dllimport) int __cdecl _pclose(
              FILE* _Stream
            );

         
        __declspec(dllimport) FILE* __cdecl _popen(
              char const* _Command,
              char const* _Mode
            );

    #line 344 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

     
    
    __declspec(dllimport) int __cdecl putc(
             int   _Character,
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl putchar(
          int _Character
        );

    
    __declspec(dllimport) int __cdecl puts(
          char const* _Buffer
        );

     
    
    __declspec(dllimport) int __cdecl _putw(
             int   _Word,
          FILE* _Stream
        );

    __declspec(dllimport) int __cdecl remove(
          char const* _FileName
        );

     
    __declspec(dllimport) int __cdecl rename(
          char const* _OldFileName,
          char const* _NewFileName
        );

    __declspec(dllimport) 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."))
        __declspec(dllimport) int __cdecl unlink(
              char const* _FileName
            );

    #line 391 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    __declspec(dllimport) void __cdecl rewind(
          FILE* _Stream
        );

    
    __declspec(dllimport) 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."))
    __declspec(dllimport) void __cdecl setbuf(
                                                      FILE* _Stream,
            char* _Buffer
        );

    
    __declspec(dllimport) int __cdecl _setmaxstdio(
          int _Maximum
        );

     
    
    __declspec(dllimport) int __cdecl setvbuf(
                               FILE*  _Stream,
            char*  _Buffer,
                                  int    _Mode,
                                  size_t _Size
        );

    


#line 423 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

     
    __declspec(dllimport) __declspec(allocator) char* __cdecl _tempnam(
          char const* _DirectoryName,
          char const* _FilePrefix
        );

    

#line 433 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport)  char* __cdecl tmpnam(  char *_Buffer);
#line 448 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

     
    
    __declspec(dllimport) int __cdecl ungetc(
             int   _Character,
          FILE* _Stream
        );



    
    
    
    
    
    __declspec(dllimport) void __cdecl _lock_file(
          FILE* _Stream
        );

    __declspec(dllimport) void __cdecl _unlock_file(
          FILE* _Stream
        );

     
    
    __declspec(dllimport) int __cdecl _fclose_nolock(
          FILE* _Stream
        );

     
    
    __declspec(dllimport) int __cdecl _fflush_nolock(
          FILE* _Stream
        );

     
    
    __declspec(dllimport) int __cdecl _fgetc_nolock(
          FILE* _Stream
        );

     
    
    __declspec(dllimport) int __cdecl _fputc_nolock(
             int   _Character,
          FILE* _Stream
        );

    
    __declspec(dllimport) size_t __cdecl _fread_nolock(
          void*  _Buffer,
                                                      size_t _ElementSize,
                                                      size_t _ElementCount,
                                                   FILE*  _Stream
        );

    
     
    __declspec(dllimport) size_t __cdecl _fread_nolock_s(
          void*  _Buffer,
                              size_t _BufferSize,
                                                                      size_t _ElementSize,
                                                                      size_t _ElementCount,
                                                                   FILE*  _Stream
        );

    
    __declspec(dllimport) int __cdecl _fseek_nolock(
          FILE* _Stream,
             long  _Offset,
             int   _Origin
        );

    
    __declspec(dllimport) int __cdecl _fseeki64_nolock(
          FILE*   _Stream,
             __int64 _Offset,
             int     _Origin
        );

     
    __declspec(dllimport) long __cdecl _ftell_nolock(
          FILE* _Stream
        );

     
    __declspec(dllimport) __int64 __cdecl _ftelli64_nolock(
          FILE* _Stream
        );

    
    __declspec(dllimport) size_t __cdecl _fwrite_nolock(
          void const* _Buffer,
                                                    size_t      _ElementSize,
                                                    size_t      _ElementCount,
                                                 FILE*       _Stream
        );

    
    __declspec(dllimport) int __cdecl _getc_nolock(
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl _putc_nolock(
             int   _Character,
          FILE* _Stream
        );

    
    __declspec(dllimport) int __cdecl _ungetc_nolock(
             int   _Character,
          FILE* _Stream
        );

    
    
    
    



    














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



    __declspec(dllimport) int* __cdecl __p__commode(void);

    


        
    #line 596 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"



    
    

#line 603 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    
    
    
    
    
    __declspec(dllimport) int __cdecl __stdio_common_vfprintf(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    __declspec(dllimport) int __cdecl __stdio_common_vfprintf_s(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vfprintf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 662 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            return _vfprintf_s_l(_Stream, _Format, 0, _ArgList);
        }
    #line 693 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    #line 695 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vfprintf_p_l(_Stream, _Format, 0, _ArgList);
    }
    #line 724 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"

    #line 782 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.0\\ucrt\\stdio.h"

    __declspec(dllimport) int __cdecl _set_printf_count_output(
          int _Value
        );

    __declspec(dllimport) 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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\stdio.h"

    #line 893 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.0\\ucrt\\stdio.h"

    
    __inline int __cdecl printf(
            char const* const _Format,
        ...)
    

#line 956 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\stdio.h"

    #line 1004 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.0\\ucrt\\stdio.h"


    
    
    
    
    
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vfscanf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 1084 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            return _vfscanf_s_l(_Stream, _Format, 0, _ArgList);
        }
    #line 1118 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    #line 1120 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"

    #line 1178 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\stdio.h"

    #line 1256 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\stdio.h"

    #line 1330 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"



    
    
    
    
    
     
    __declspec(dllimport) int __cdecl __stdio_common_vsprintf(
                                             unsigned __int64 _Options,
                 char*            _Buffer,
                                             size_t           _BufferCount,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
    __declspec(dllimport) int __cdecl __stdio_common_vsprintf_s(
                                             unsigned __int64 _Options,
                     char*            _Buffer,
                                             size_t           _BufferCount,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
    __declspec(dllimport) 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
        );

     
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vsnprintf_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1415 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    








#line 1426 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"

    #line 1526 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"

    #line 1641 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vscprintf_l(_Format, 0, _ArgList);
    }
    #line 1672 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vscprintf_p_l(_Format, 0, _ArgList);
    }
    #line 1703 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

        _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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
            _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.22621.0\\ucrt\\stdio.h"

    #line 1834 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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)(__va_start(&_ArgList, _Format))))); return vsprintf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1841 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.0\\ucrt\\stdio.h"

    








#line 1916 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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)(__va_start(&_ArgList, _Format))))); return _vsnprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 2057 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _scprintf(
            char const* const _Format,
        ...)
    

#line 2083 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _Result = _vscprintf_p(_Format, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2127 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"

    
    
    
    
    
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        return _vsscanf_l(_Buffer, _Format, 0, _ArgList);
    }
    #line 2172 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            return _vsscanf_s_l(_Buffer, _Format, 0, _ArgList);
        }
    #line 2208 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"

        #pragma warning(pop)

    #line 2219 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

            _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.22621.0\\ucrt\\stdio.h"

    #line 2299 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.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.22621.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

        _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.22621.0\\ucrt\\stdio.h"

    #pragma warning(pop)

    

#line 2403 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"



    
    
    
    
    
    

        

        


#line 2419 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
        __declspec(dllimport) char* __cdecl tempnam(
              char const* _Directory,
              char const* _FilePrefix
            );

        

#line 2429 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.")) __declspec(dllimport) 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."))    __declspec(dllimport) 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."))  __declspec(dllimport) 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."))    __declspec(dllimport) 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."))  __declspec(dllimport) 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."))  __declspec(dllimport) 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."))      __declspec(dllimport) 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."))      __declspec(dllimport) 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."))     __declspec(dllimport) int   __cdecl rmtmp(void);

    #line 2441 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"
#line 2442 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 2449 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\stdio.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 :: _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 98 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdio"
#line 99 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstdio"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cwchar"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"









#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_memcpy_s.h"







#pragma once


#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {




    __declspec(dllimport) int* __cdecl _errno(void);
    

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

    __declspec(dllimport) unsigned long* __cdecl __doserrno(void);
    

    __declspec(dllimport) errno_t __cdecl _set_doserrno(  unsigned long _Value);
    __declspec(dllimport) errno_t __cdecl _get_doserrno(  unsigned long * _Value);
#line 35 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\errno.h"










































    
    
    
    
    
#line 83 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\errno.h"






    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
#line 131 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\errno.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 138 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\errno.h"
#pragma external_header(pop)
#line 12 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_memcpy_s.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_string.h"

#pragma warning(pop) 
#pragma external_header(pop)
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.0\\ucrt\\corecrt_memcpy_s.h"




#pragma warning(pop) 
} __pragma(pack(pop))
#pragma external_header(pop)
#line 16 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {







    
     
    __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wconio.h"

    
    __declspec(dllimport) int __cdecl _cputws(
          wchar_t const* _Buffer
        );

          __declspec(dllimport) wint_t __cdecl _getwch  (void);
          __declspec(dllimport) wint_t __cdecl _getwche (void);
     __declspec(dllimport) wint_t __cdecl _putwch  (  wchar_t _Character);
     __declspec(dllimport) wint_t __cdecl _ungetwch(  wint_t  _Character);

          __declspec(dllimport) wint_t __cdecl _getwch_nolock  (void);
          __declspec(dllimport) wint_t __cdecl _getwche_nolock (void);
     __declspec(dllimport) wint_t __cdecl _putwch_nolock  (  wchar_t _Character);
     __declspec(dllimport) wint_t __cdecl _ungetwch_nolock(  wint_t  _Character);



    
    
    
    
    
    
    __declspec(dllimport) int __cdecl __conio_common_vcwprintf(
                                             unsigned __int64 _Options,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __declspec(dllimport) int __cdecl __conio_common_vcwprintf_s(
                                             unsigned __int64 _Options,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwprintf_l(_Format, 0, _ArgList);
    }
#line 113 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwprintf_s_l(_Format, 0, _ArgList);
    }
#line 140 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwprintf_p_l(_Format, 0, _ArgList);
    }
#line 167 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.0\\ucrt\\corecrt_wconio.h"



    
    
    
    
    
    
    __declspec(dllimport) 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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwscanf_l(_Format, 0, _ArgList);
    }
#line 316 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwscanf_s_l(_Format, 0, _ArgList);
    }
#line 345 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));

        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));

        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(__va_start(&_ArgList, _Locale)))));
        _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.22621.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.22621.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(__va_start(&_ArgList, _Format)))));
        _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.22621.0\\ucrt\\corecrt_wconio.h"

#line 421 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wconio.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 17 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wctype.h"
        
    #line 34 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wctype.h"

    __declspec(dllimport) const unsigned short* __cdecl __pctype_func(void);
    __declspec(dllimport) const wctype_t*       __cdecl __pwctype_func(void);

    



        
        
    #line 45 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wctype.h"
#line 46 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wctype.h"





















  __declspec(dllimport) int __cdecl iswalnum  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswalpha  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswascii  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswblank  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswcntrl  (  wint_t _C);


  __declspec(dllimport) int __cdecl iswdigit  (  wint_t _C);

  __declspec(dllimport) int __cdecl iswgraph  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswlower  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswprint  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswpunct  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswspace  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswupper  (  wint_t _C);
  __declspec(dllimport) int __cdecl iswxdigit (  wint_t _C);
  __declspec(dllimport) int __cdecl __iswcsymf(  wint_t _C);
  __declspec(dllimport) int __cdecl __iswcsym (  wint_t _C);

  __declspec(dllimport) int __cdecl _iswalnum_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswalpha_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswblank_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswcntrl_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswdigit_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswgraph_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswlower_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswprint_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswpunct_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswspace_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswupper_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswxdigit_l(  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswcsymf_l (  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl _iswcsym_l  (  wint_t _C,   _locale_t _Locale);


  __declspec(dllimport) wint_t __cdecl towupper(  wint_t _C);
  __declspec(dllimport) wint_t __cdecl towlower(  wint_t _C);
  __declspec(dllimport) int    __cdecl iswctype(  wint_t _C,   wctype_t _Type);

  __declspec(dllimport) wint_t __cdecl _towupper_l(  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) wint_t __cdecl _towlower_l(  wint_t _C,   _locale_t _Locale);
  __declspec(dllimport) int    __cdecl _iswctype_l(  wint_t _C,   wctype_t _Type,   _locale_t _Locale);



      __declspec(dllimport) int __cdecl isleadbyte(  int _C);
      __declspec(dllimport) 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.")) __declspec(dllimport) int __cdecl is_wctype(  wint_t _C,   wctype_t _Type);
#line 117 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wctype.h"


















































































#line 200 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wctype.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 18 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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(dllimport) __declspec(allocator) wchar_t* __cdecl _wgetcwd(
      wchar_t* _DstBuf,
                                  int      _SizeInWords
    );

 
   
__declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wgetdcwd(
                                  int      _Drive,
      wchar_t* _DstBuf,
                                  int      _SizeInWords
    );






 
__declspec(dllimport) int __cdecl _wchdir(
      wchar_t const* _Path
    );

 
__declspec(dllimport) int __cdecl _wmkdir(
      wchar_t const* _Path
    );

 
__declspec(dllimport) int __cdecl _wrmdir(
      wchar_t const* _Path
    );



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 19 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wio.h"








#pragma once


#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_share.h"


#pragma warning(pop) 
#pragma external_header(pop)
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.0\\ucrt\\corecrt_wio.h"

 
__declspec(dllimport) int __cdecl _waccess(
      wchar_t const* _FileName,
        int            _AccessMode
    );


__declspec(dllimport) errno_t __cdecl _waccess_s(
      wchar_t const* _FileName,
        int            _AccessMode
    );

 
__declspec(dllimport) 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."))
__declspec(dllimport) int __cdecl _wcreat(
      wchar_t const* _FileName,
        int            _PermissionMode
    );

 
 
__declspec(dllimport) intptr_t __cdecl _wfindfirst32(
      wchar_t const*         _FileName,
       struct _wfinddata32_t* _FindData
    );

 
 
__declspec(dllimport) int __cdecl _wfindnext32(
       intptr_t               _FindHandle,
      struct _wfinddata32_t* _FindData
    );

__declspec(dllimport) int __cdecl _wunlink(
      wchar_t const* _FileName
    );

 
__declspec(dllimport) int __cdecl _wrename(
      wchar_t const* _OldFileName,
      wchar_t const* _NewFileName
    );

__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _wmktemp( wchar_t *_TemplateName);
#line 157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wio.h"

 
 
__declspec(dllimport) intptr_t __cdecl _wfindfirst32i64(
      wchar_t const*            _FileName,
       struct _wfinddata32i64_t* _FindData
    );

 
 
__declspec(dllimport) intptr_t __cdecl _wfindfirst64i32(
      wchar_t const*            _FileName,
       struct _wfinddata64i32_t* _FindData
    );

 
 
__declspec(dllimport) intptr_t __cdecl _wfindfirst64(
      wchar_t const*         _FileName,
       struct _wfinddata64_t* _FindData
    );

 
 
__declspec(dllimport) int __cdecl _wfindnext32i64(
       intptr_t                  _FindHandle,
      struct _wfinddata32i64_t* _FindData
    );

 
 
__declspec(dllimport) int __cdecl _wfindnext64i32(
       intptr_t                  _FindHandle,
      struct _wfinddata64i32_t* _FindData
    );

 
 
__declspec(dllimport) int __cdecl _wfindnext64(
       intptr_t               _FindHandle,
      struct _wfinddata64_t* _FindData
    );


__declspec(dllimport) errno_t __cdecl _wsopen_s(
       int*           _FileHandle,
      wchar_t const* _FileName,
        int            _OpenFlag,
        int            _ShareFlag,
        int            _PermissionFlag
    );

__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wio.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 20 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {




    

        __declspec(dllimport) intptr_t __cdecl _wexecl(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wexecle(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wexeclp(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wexeclpe(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wexecv(
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

        __declspec(dllimport) intptr_t __cdecl _wexecve(
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

        __declspec(dllimport) intptr_t __cdecl _wexecvp(
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

        __declspec(dllimport) intptr_t __cdecl _wexecvpe(
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

        __declspec(dllimport) intptr_t __cdecl _wspawnl(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wspawnle(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wspawnlp(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wspawnlpe(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

        __declspec(dllimport) intptr_t __cdecl _wspawnv(
                int                   _Mode,
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

        __declspec(dllimport) intptr_t __cdecl _wspawnve(
                    int                   _Mode,
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

        __declspec(dllimport) intptr_t __cdecl _wspawnvp(
                int                   _Mode,
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

        __declspec(dllimport) intptr_t __cdecl _wspawnvpe(
                    int                   _Mode,
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

        __declspec(dllimport) int __cdecl _wsystem(
              wchar_t const* _Command
            );

    #line 121 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wprocess.h"
#line 122 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wprocess.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 21 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"


#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {










    
    __declspec(dllimport) errno_t __cdecl wcscat_s(
          wchar_t* _Destination,
          rsize_t _SizeInWords,
          wchar_t const* _Source
        );

    
    __declspec(dllimport) errno_t __cdecl wcscpy_s(
          wchar_t* _Destination,
          rsize_t _SizeInWords,
          wchar_t const* _Source
        );

    
    __declspec(dllimport) errno_t __cdecl wcsncat_s(
          wchar_t*       _Destination,
                                     rsize_t        _SizeInWords,
               wchar_t const* _Source,
                                     rsize_t        _MaxCount
        );

    
    __declspec(dllimport) errno_t __cdecl wcsncpy_s(
          wchar_t*       _Destination,
                                  rsize_t        _SizeInWords,
            wchar_t const* _Source,
                                  rsize_t        _MaxCount
        );

     
    __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"











#line 81 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

 
__declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wcsdup(
      wchar_t const* _String
    );



#line 90 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl wcscat( wchar_t *_Destination,  wchar_t const* _Source);
#line 105 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"
#line 106 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

 
__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl wcscpy( wchar_t *_Destination,  wchar_t const* _Source);
#line 124 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

 
__declspec(dllimport) size_t __cdecl wcscspn(
      wchar_t const* _String,
      wchar_t const* _Control
    );

 
__declspec(dllimport) size_t __cdecl wcslen(
      wchar_t const* _String
    );

 

#line 141 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

#line 145 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"
__declspec(dllimport) size_t __cdecl wcsnlen(
      wchar_t const* _Source,
                            size_t         _MaxCount
    );



     
    
#line 157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"
    
#line 161 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"

 
__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"

 
__declspec(dllimport) wchar_t const* __cdecl wcspbrk(
      wchar_t const* _String,
      wchar_t const* _Control
    );

 
__declspec(dllimport) 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."))
__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"
        



    #line 237 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.22621.0\\ucrt\\corecrt_wstring.h"

#line 263 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
__declspec(dllimport) wchar_t* __cdecl _wcserror(
      int _ErrorNumber
    );


__declspec(dllimport) 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.22621.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."))
__declspec(dllimport) wchar_t* __cdecl __wcserror(
      wchar_t const* _String
    );

 __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"

  __declspec(dllimport) int __cdecl _wcsicmp(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

  __declspec(dllimport) int __cdecl _wcsicmp_l(
        wchar_t const* _String1,
        wchar_t const* _String2,
      _locale_t      _Locale
    );

  __declspec(dllimport) int __cdecl _wcsnicmp(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

  __declspec(dllimport) int __cdecl _wcsnicmp_l(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount,
                        _locale_t      _Locale
    );

 __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"

__declspec(dllimport) wchar_t* __cdecl _wcsrev(
      wchar_t* _String
    );

 __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _wcsset(  wchar_t *_String,   wchar_t _Value);
#line 372 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

 __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _wcslwr( wchar_t *_String);
#line 387 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _wcslwr_l(  wchar_t *_String,   _locale_t _Locale);
#line 407 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _wcsupr( wchar_t *_String);
#line 423 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) wchar_t* __cdecl _wcsupr_l(  wchar_t *_String,   _locale_t _Locale);
#line 443 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

 

__declspec(dllimport) size_t __cdecl wcsxfrm(
        wchar_t*       _Destination,
                                         wchar_t const* _Source,
                size_t         _MaxCount
    );

 

__declspec(dllimport) size_t __cdecl _wcsxfrm_l(
        wchar_t*       _Destination,
                                         wchar_t const* _Source,
                size_t         _MaxCount,
                                       _locale_t      _Locale
    );

 
__declspec(dllimport) int __cdecl wcscoll(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

 
__declspec(dllimport) int __cdecl _wcscoll_l(
        wchar_t const* _String1,
        wchar_t const* _String2,
      _locale_t      _Locale
    );

 
__declspec(dllimport) int __cdecl _wcsicoll(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

 
__declspec(dllimport) int __cdecl _wcsicoll_l(
        wchar_t const* _String1,
        wchar_t const* _String2,
      _locale_t      _Locale
    );

 
__declspec(dllimport) int __cdecl _wcsncoll(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

 
__declspec(dllimport) int __cdecl _wcsncoll_l(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount,
                        _locale_t      _Locale
    );

 
__declspec(dllimport) int __cdecl _wcsnicoll(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

 
__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wstring.h"









    


#line 568 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) wchar_t* __cdecl wcsdup(
          wchar_t const* _String
        );

    

#line 577 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
     
    __declspec(dllimport) 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."))
     
    __declspec(dllimport) 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."))
     
    __declspec(dllimport) 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."))
     
    __declspec(dllimport) 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."))
     
    __declspec(dllimport) 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."))
    __declspec(dllimport) int __cdecl wcsicoll(
          wchar_t const* _String1,
          wchar_t const* _String2
        );

#line 634 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"



} __pragma(pack(pop))

#line 640 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wstring.h"

#pragma warning(pop) 
#pragma external_header(pop)
#line 24 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
 
 
__declspec(dllimport) wchar_t* __cdecl _wasctime(
      struct tm const* _Tm
    );

 

__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wtime.h"

 

__declspec(dllimport) size_t __cdecl wcsftime(
       wchar_t*         _Buffer,
                               size_t           _SizeInWords,
                             wchar_t const*   _Format,
                               struct tm const* _Tm
    );

 

__declspec(dllimport) 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."))
__declspec(dllimport) wchar_t* __cdecl _wctime32(
      __time32_t const* _Time
    );


__declspec(dllimport) 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.22621.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."))
__declspec(dllimport) wchar_t* __cdecl _wctime64(
      __time64_t const* _Time
    );


__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_wtime.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport)  wchar_t* __cdecl _wstrdate( wchar_t *_Buffer);
#line 139 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wtime.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport)  wchar_t* __cdecl _wstrtime( wchar_t *_Buffer);
#line 155 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_wtime.h"
#line 204 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_wtime.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 25 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\sys/stat.h"







#pragma once


#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\sys/types.h"
#line 25 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\sys/types.h"
#line 37 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\sys/types.h"
#line 49 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\sys/types.h"


#pragma warning(pop) 
#pragma external_header(pop)
#line 12 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\sys/stat.h"


















    
    
    
    
    
    
    
#line 128 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\sys/stat.h"
















    
    
    
    
    
    
#line 151 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\sys/stat.h"



__declspec(dllimport) int __cdecl _fstat32(
       int             _FileHandle,
      struct _stat32* _Stat
    );

__declspec(dllimport) int __cdecl _fstat32i64(
       int                _FileHandle,
      struct _stat32i64* _Stat
    );

__declspec(dllimport) int __cdecl _fstat64i32(
       int                _FileHandle,
      struct _stat64i32* _Stat
    );

__declspec(dllimport) int __cdecl _fstat64(
       int             _FileHandle,
      struct _stat64* _Stat
    );

__declspec(dllimport) int __cdecl _stat32(
      char const*     _FileName,
       struct _stat32* _Stat
    );

__declspec(dllimport) int __cdecl _stat32i64(
      char const*        _FileName,
       struct _stat32i64* _Stat
    );

__declspec(dllimport) int __cdecl _stat64i32(
      char const*        _FileName,
       struct _stat64i32* _Stat
    );

__declspec(dllimport) int __cdecl _stat64(
      char const*     _FileName,
       struct _stat64* _Stat
    );

__declspec(dllimport) int __cdecl _wstat32(
      wchar_t const*  _FileName,
       struct _stat32* _Stat
    );

__declspec(dllimport) int __cdecl _wstat32i64(
      wchar_t const*     _FileName,
       struct _stat32i64* _Stat
    );

__declspec(dllimport) int __cdecl _wstat64i32(
      wchar_t const*     _FileName,
       struct _stat64i32* _Stat
    );

__declspec(dllimport) 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.22621.0\\ucrt\\sys/stat.h"
#line 246 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\sys/stat.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 26 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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;





        
    __declspec(dllimport) wchar_t* __cdecl _wsetlocale(
                int            _Category,
          wchar_t const* _Locale
        );

    
    __declspec(dllimport) _locale_t __cdecl _wcreate_locale(
            int            _Category,
          wchar_t const* _Locale
        );



    __declspec(dllimport) wint_t __cdecl btowc(
          int _Ch
        );

    __declspec(dllimport) size_t __cdecl mbrlen(
            char const* _Ch,
                                                    size_t      _SizeInBytes,
                                                 mbstate_t*  _State
        );

    __declspec(dllimport) size_t __cdecl mbrtowc(
                                  wchar_t*    _DstCh,
            char const* _SrcCh,
                                                    size_t      _SizeInBytes,
                                                 mbstate_t*  _State
        );

     
    __declspec(dllimport) 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.22621.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."))  __declspec(dllimport) 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.22621.0\\ucrt\\wchar.h"

     
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) size_t __cdecl wcrtomb(  char *_Dest,  wchar_t _Source,  mbstate_t* _State);
#line 131 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"

     
    __declspec(dllimport) 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.22621.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.")) __declspec(dllimport) 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.22621.0\\ucrt\\wchar.h"

    __declspec(dllimport) 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.22621.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.22621.0\\ucrt\\wchar.h"

#line 281 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 287 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\wchar.h"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cwchar"
#line 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cwchar"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.h"












#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"













#pragma once





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



#pragma warning(disable: 28251)


extern "C" {
#line 30 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"






























#line 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"


#line 64 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"






#line 71 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 76 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 81 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 86 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"






#line 93 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 98 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 103 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 108 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 113 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"




#line 118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"









unsigned char _BitScanForward(unsigned long * _Index, unsigned long _Mask);
unsigned char _BitScanForward64(unsigned long * _Index, unsigned __int64 _Mask);

unsigned char _BitScanReverse(unsigned long * _Index, unsigned long _Mask);
unsigned char _BitScanReverse64(unsigned long * _Index, unsigned __int64 _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);
__int64 _interlockedand64(__int64 volatile * _Value, __int64 _Mask);



char _InterlockedAnd8(char volatile * _Value, char _Mask);






long  _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);






unsigned char _InterlockedCompareExchange128(__int64 volatile * _Destination, __int64 _ExchangeHigh, __int64 _ExchangeLow, __int64 * _ComparandResult);



long  _InterlockedDecrement(long volatile * _Addend);

short _InterlockedDecrement16(short volatile * _Addend);
__int64 _InterlockedDecrement64(__int64 volatile * _Addend);
__int64 _interlockeddecrement64(__int64 volatile * _Addend);
long  _InterlockedExchange(long volatile * _Target, long _Value);

short _InterlockedExchange16(short volatile * _Target, short _Value);



__int64 _InterlockedExchange64(__int64 volatile * _Target, __int64 _Value);
__int64 _interlockedexchange64(__int64 volatile * _Target, __int64 _Value);



char _InterlockedExchange8(char volatile * _Target, char _Value);



long  _InterlockedExchangeAdd(long volatile * _Addend, long _Value);
short _InterlockedExchangeAdd16(short volatile * _Addend, short _Value);



__int64 _InterlockedExchangeAdd64(__int64 volatile * _Addend, __int64 _Value);
__int64 _interlockedexchangeadd64(__int64 volatile * _Addend, __int64 _Value);



char _InterlockedExchangeAdd8(char volatile * _Addend, char _Value);









long  _InterlockedIncrement(long volatile * _Addend);

short _InterlockedIncrement16(short volatile * _Addend);
__int64 _InterlockedIncrement64(__int64 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);
__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);
__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 __int64 __lzcnt64(unsigned __int64);
unsigned int __popcnt(unsigned int);
unsigned short __popcnt16(unsigned short);
unsigned __int64 __popcnt64(unsigned __int64);
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 __int64 __shiftleft128(unsigned __int64 _LowPart, unsigned __int64 _HighPart, unsigned char _Shift);
unsigned __int64 __shiftright128(unsigned __int64 _LowPart, unsigned __int64 _HighPart, unsigned char _Shift);

unsigned int _tzcnt_u32(unsigned int);
unsigned __int64 _tzcnt_u64(unsigned __int64);
#line 288 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"
unsigned __int64 _umul128(unsigned __int64 _Multiplier, unsigned __int64 _Multiplicand, unsigned __int64 * _HighProduct);

unsigned __int64 __cdecl _udiv128(unsigned __int64 _HighDividend, unsigned __int64 _LowDividend, unsigned __int64 _Divisor, unsigned __int64* _Remainder);
unsigned char __cdecl _addcarry_u64(unsigned char, unsigned __int64, unsigned __int64, unsigned __int64 *);
unsigned char __cdecl _subborrow_u64(unsigned char, unsigned __int64, unsigned __int64, unsigned __int64 *);
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);







#line 313 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"











constexpr void * __cdecl __builtin_assume_aligned(const void *, size_t, ...) noexcept;


#line 328 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"
#line 329 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"








}
#line 339 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"
#pragma warning(pop) 
#line 341 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.inl.h"
#pragma external_header(pop)
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.h"
#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin0.h"
#pragma external_header(pop)
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { 
    __pragma(warning(push)) __pragma(warning(disable : 4996))
     static constexpr float_denorm_style has_denorm = denorm_absent;
     static constexpr bool has_denorm_loss          = false;
    __pragma(warning(pop))

    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 { 
    __pragma(warning(push)) __pragma(warning(disable : 4996))
     static constexpr float_denorm_style has_denorm = denorm_present;
    __pragma(warning(pop))

    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 363 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 718 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 1002 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits"
#line 1003 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\limits"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"





#pragma once


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"









#pragma once










#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"







#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new_debug.h"



#pragma pack(pop)

} 
#line 63 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_new_debug.h"

#pragma warning(pop) 
#pragma external_header(pop)
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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;


























    

        __declspec(dllimport) int*  __cdecl __p__crtDbgFlag(void);
        __declspec(dllimport) long* __cdecl __p__crtBreakAlloc(void);

        
        

        __declspec(dllimport) _CRT_ALLOC_HOOK __cdecl _CrtGetAllocHook(void);

        __declspec(dllimport) _CRT_ALLOC_HOOK __cdecl _CrtSetAllocHook(
              _CRT_ALLOC_HOOK _PfnNewHook
            );

        __declspec(dllimport) _CRT_DUMP_CLIENT __cdecl _CrtGetDumpClient(void);

        __declspec(dllimport) _CRT_DUMP_CLIENT __cdecl _CrtSetDumpClient(
              _CRT_DUMP_CLIENT _PFnNewDump
            );

    #line 175 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"

    __declspec(dllimport) int __cdecl _CrtCheckMemory(void);

    typedef void (__cdecl* _CrtDoForAllClientObjectsCallback)(void*, void*);

    __declspec(dllimport) void __cdecl _CrtDoForAllClientObjects(
          _CrtDoForAllClientObjectsCallback _Callback,
          void*                             _Context
        );

    __declspec(dllimport) int __cdecl _CrtDumpMemoryLeaks(void);

    __declspec(dllimport) int __cdecl _CrtIsMemoryBlock(
           void const*  _Block,
               unsigned int _Size,
          long*        _RequestNumber,
          char**       _FileName,
          int*         _LineNumber
        );

     
    __declspec(dllimport) int __cdecl _CrtIsValidHeapPointer(
          void const* _Pointer
        );

     
    __declspec(dllimport) int __cdecl _CrtIsValidPointer(
          void const*  _Pointer,
              unsigned int _Size,
              int          _ReadWrite
        );

    __declspec(dllimport) void __cdecl _CrtMemCheckpoint(
          _CrtMemState* _State
        );

    __declspec(dllimport) int __cdecl _CrtMemDifference(
          _CrtMemState*       _State,
           _CrtMemState const* _OldState,
           _CrtMemState const* _NewState
        );

    __declspec(dllimport) void __cdecl _CrtMemDumpAllObjectsSince(
          _CrtMemState const* _State
        );

    __declspec(dllimport) void __cdecl _CrtMemDumpStatistics(
          _CrtMemState const* _State
        );

     
    __declspec(dllimport) int __cdecl _CrtReportBlockType(
          void const* _Block
        );

    __declspec(dllimport) long __cdecl _CrtSetBreakAlloc(
          long _NewValue
        );

    __declspec(dllimport) int __cdecl _CrtSetDbgFlag(
          int _NewFlag
        );

#line 239 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"
















































    












































    __declspec(dllimport) void __cdecl _aligned_free_dbg(
            void* _Block
        );

         
    __declspec(dllimport) __declspec(allocator) void* __cdecl _aligned_malloc_dbg(
                size_t      _Size,
                size_t      _Alignment,
          char const* _FileName,
                int         _LineNumber
        );

    __declspec(dllimport) size_t __cdecl _aligned_msize_dbg(
          void*  _Block,
                   size_t _Alignment,
                   size_t _Offset
        );

         
    __declspec(dllimport) __declspec(allocator) void* __cdecl _aligned_offset_malloc_dbg(
                size_t      _Size,
                size_t      _Alignment,
                size_t      _Offset,
          char const* _FileName,
                int         _LineNumber
        );

           
    __declspec(dllimport) __declspec(allocator) void* __cdecl _aligned_offset_realloc_dbg(
            void*       _Block,
                                    size_t      _Size,
                                    size_t      _Alignment,
                                    size_t      _Offset,
                              char const* _FileName,
                                    int         _LineNumber
        );

           
    __declspec(dllimport) __declspec(allocator) void* __cdecl _aligned_offset_recalloc_dbg(
            void*       _Block,
                                    size_t      _Count,
                                    size_t      _Size,
                                    size_t      _Alignment,
                                    size_t      _Offset,
                              char const* _FileName,
                                    int         _LineNumber
        );

           
    __declspec(dllimport) __declspec(allocator) void* __cdecl _aligned_realloc_dbg(
            void*       _Block,
                                    size_t      _Size,
                                    size_t      _Alignment,
                              char const* _FileName,
                                    int         _LineNumber
        );

           
    __declspec(dllimport) __declspec(allocator) void* __cdecl _aligned_recalloc_dbg(
            void*       _Block,
                                    size_t      _Count,
                                    size_t      _Size,
                                    size_t      _Alignment,
                              char const* _FileName,
                                    int         _LineNumber
        );

         
    __declspec(dllimport) __declspec(allocator) void* __cdecl _calloc_dbg(
                size_t      _Count,
                size_t      _Size,
                int         _BlockUse,
          char const* _FileName,
                int         _LineNumber
        );

         
    __declspec(dllimport) __declspec(allocator) void* __cdecl _expand_dbg(
          void*       _Block,
                   size_t      _Size,
                   int         _BlockUse,
             char const* _FileName,
                   int         _LineNumber
        );

    __declspec(dllimport) void __cdecl _free_dbg(
            void* _Block,
                                    int   _BlockUse
        );

         
    __declspec(dllimport) __declspec(allocator) void* __cdecl _malloc_dbg(
                size_t      _Size,
                int         _BlockUse,
          char const* _FileName,
                int         _LineNumber
        );

    __declspec(dllimport) size_t __cdecl _msize_dbg(
          void* _Block,
                   int   _BlockUse
        );

           
    __declspec(dllimport) __declspec(allocator) void* __cdecl _realloc_dbg(
            void*       _Block,
                                    size_t      _Size,
                                    int         _BlockUse,
                              char const* _FileName,
                                    int         _LineNumber
        );

           
    __declspec(dllimport) __declspec(allocator) void* __cdecl _recalloc_dbg(
            void*       _Block,
                                    size_t      _Count,
                                    size_t      _Size,
                                    int         _BlockUse,
                              char const* _FileName,
                                    int         _LineNumber
        );

     
    
    __declspec(dllimport) errno_t __cdecl _dupenv_s_dbg(
          char** _PBuffer,
                               size_t*     _PBufferSizeInBytes,
                                  char const* _VarName,
                                    int          _BlockType,
                              char const* _FileName,
                                    int          _LineNumber
        );

     
       
    __declspec(dllimport) __declspec(allocator) char* __cdecl _fullpath_dbg(
          char*       _FullPath,
                                    char const* _Path,
                                      size_t      _SizeInBytes,
                                      int         _BlockType,
                                char const* _FileName,
                                      int         _LineNumber
        );

     
       
    __declspec(dllimport) __declspec(allocator) char* __cdecl _getcwd_dbg(
          char*       _DstBuf,
                                      int         _SizeInBytes,
                                      int         _BlockType,
                                char const* _FileName,
                                      int         _LineNumber
        );


     
       
    __declspec(dllimport) __declspec(allocator) char* __cdecl _getdcwd_dbg(
                                      int         _Drive,
          char*       _DstBuf,
                                      int         _SizeInBytes,
                                      int         _BlockType,
                                char const* _FileName,
                                      int         _LineNumber
        );

       
    __declspec(dllimport) __declspec(allocator) char* __cdecl _strdup_dbg(
          char const* _String,
                int         _BlockUse,
          char const* _FileName,
                int         _LineNumber
        );

       
    __declspec(dllimport) __declspec(allocator) char* __cdecl _tempnam_dbg(
          char const* _DirName,
          char const* _FilePrefix,
                int         _BlockType,
          char const* _FileName,
                int         _LineNumber
        );

     
       
    __declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wcsdup_dbg(
          wchar_t const* _String,
                int            _BlockUse,
          char const*    _FileName,
                int            _LineNumber
        );

     
    
    __declspec(dllimport) errno_t __cdecl _wdupenv_s_dbg(
          wchar_t** _PBuffer,
                                 size_t*         _PBufferSizeInWords,
                                    wchar_t const* _VarName,
                                      int             _BlockType,
                                char const*    _FileName,
                                      int             _LineNumber
        );

     
       
    __declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wfullpath_dbg(
          wchar_t*       _FullPath,
                                    wchar_t const* _Path,
                                      size_t         _SizeInWords,
                                      int            _BlockType,
                                char const*    _FileName,
                                      int            _LineNumber
        );

     
       
    __declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wgetcwd_dbg(
          wchar_t*    _DstBuf,
                                      int         _SizeInWords,
                                      int         _BlockType,
                                char const* _FileName,
                                      int         _LineNumber
        );

     
       
    __declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wgetdcwd_dbg(
                                      int         _Drive,
          wchar_t*    _DstBuf,
                                      int         _SizeInWords,
                                      int         _BlockType,
                                char const* _FileName,
                                      int         _LineNumber
        );

       
    __declspec(dllimport) __declspec(allocator) wchar_t* __cdecl _wtempnam_dbg(
          wchar_t const* _DirName,
          wchar_t const* _FilePrefix,
                int            _BlockType,
          char const*    _FileName,
                int            _LineNumber
        );

    
    

    







#line 588 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"

#line 590 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"





















    __declspec(dllimport) int __cdecl _CrtDbgReport(
                int         _ReportType,
          char const* _FileName,
                int         _Linenumber,
          char const* _ModuleName,
          char const* _Format,
        ...);

    __declspec(dllimport) int __cdecl _CrtDbgReportW(
                int            _ReportType,
          wchar_t const* _FileName,
                int            _LineNumber,
          wchar_t const* _ModuleName,
          wchar_t const* _Format,
        ...);


    __declspec(dllimport) int __cdecl _VCrtDbgReportA(
                int         _ReportType,
            void*       _ReturnAddress,
          char const* _FileName,
                int         _LineNumber,
          char const* _ModuleName,
          char const* _Format,
                   va_list     _ArgList
        );

    __declspec(dllimport) int __cdecl _VCrtDbgReportW(
                int            _ReportType,
            void*          _ReturnAddress,
          wchar_t const* _FileName,
                int            _LineNumber,
          wchar_t const* _ModuleName,
          wchar_t const* _Format,
                   va_list        _ArgList
        );

    __declspec(dllimport) size_t __cdecl _CrtSetDebugFillThreshold(
          size_t _NewDebugFillThreshold
        );

    __declspec(dllimport) size_t __cdecl _CrtGetDebugFillThreshold(void);

    __declspec(dllimport) _HFILE __cdecl _CrtSetReportFile(
              int    _ReportType,
          _HFILE _ReportFile
        );

    __declspec(dllimport) int __cdecl _CrtSetReportMode(
          int _ReportType,
          int _ReportMode
        );

    

        extern long _crtAssertBusy;

        __declspec(dllimport) _CRT_REPORT_HOOK __cdecl _CrtGetReportHook(void);

        
        
        
        __declspec(dllimport) _CRT_REPORT_HOOK __cdecl _CrtSetReportHook(
              _CRT_REPORT_HOOK _PFnNewHook
            );

        __declspec(dllimport) int __cdecl _CrtSetReportHook2(
                  int              _Mode,
              _CRT_REPORT_HOOK _PFnNewHook
            );

        __declspec(dllimport) int __cdecl _CrtSetReportHookW2(
                  int               _Mode,
              _CRT_REPORT_HOOKW _PFnNewHook
            );

    #line 688 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"

#line 690 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"







































    

    
    
    
        





    #line 741 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"

    
        
    #line 745 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"

    
        
    #line 749 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"

    



    



    
    

    
    

    
    

    
    

#line 771 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"













    
#line 786 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"



























} __pragma(pack(pop))

#pragma warning(pop) 
#line 817 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\crtdbg.h"
#pragma external_header(pop)
#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"




















    

#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
        
    #line 26 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#line 27 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"



    

#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
        
    #line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#line 36 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"



    

#line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
        
    #line 44 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#line 45 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"





    


#line 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
        
        
    


#line 60 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#line 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"


    

#line 66 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
        
            
        

#line 71 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
    #line 72 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#line 73 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"


    

#line 78 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"

#line 80 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
        
    #line 82 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#line 83 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\crtdefs.h"
#pragma external_header(pop)
#line 23 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 40 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"















#line 58 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 59 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 60 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"






















































#line 115 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 116 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"











#line 128 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"








#line 138 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"


#pragma detect_mismatch("_MSC_VER", "1900")
#line 144 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"


#pragma detect_mismatch("_ITERATOR_DEBUG_LEVEL", "2")
#line 148 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"




#line 153 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 155 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 157 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#pragma detect_mismatch("RuntimeLibrary", "MDd_DynamicDebug")
#line 159 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 160 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"




#line 165 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 167 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 168 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"



#line 172 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"








#line 181 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 182 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"





























#line 212 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"





#line 218 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"





#line 224 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"






#line 231 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 232 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"





#line 238 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"
















#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"









#line 43 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"




#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"

#pragma comment(lib, "msvcprt" "d" "")






#line 57 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"

#line 59 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"

#line 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\use_ansi.h"
#pragma external_header(pop)
#line 240 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

















#line 258 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"






#line 265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 266 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"



#line 270 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"






#line 277 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 278 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"












#line 291 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"



#line 295 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 296 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"






#line 303 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 304 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"






#line 311 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 312 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"




#line 317 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"










#line 331 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

#line 333 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 334 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"



#line 338 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"



#line 342 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

namespace std {
enum _Uninitialized { 
    _Noinit
};

extern "C++" class __declspec(dllimport) _Lockit { 
public:














    __thiscall _Lockit() noexcept;
    explicit __thiscall _Lockit(int) noexcept; 
    __thiscall ~_Lockit() noexcept; 
#line 368 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 452 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"

















































#line 502 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
}



#pragma warning(pop)
#pragma pack(pop)
#line 509 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#line 510 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\yvals.h"
#pragma external_header(pop)
#line 10 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 28 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"
 extern "C++"  int __cdecl uncaught_exceptions() noexcept;

}



#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\malloc.h"













typedef struct _heapinfo
{
    int* _pentry;
    size_t _size;
    int _useflag;
} _HEAPINFO;






   
void* __cdecl _alloca(  size_t _Size);





    __declspec(dllimport) intptr_t __cdecl _get_heap_handle(void);

     
    __declspec(dllimport) int __cdecl _heapmin(void);

    
        __declspec(dllimport) int __cdecl _heapwalk(  _HEAPINFO* _EntryInfo);
    #line 69 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"

    
          __declspec(dllimport) int __cdecl _heapchk(void);
    #line 73 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"

    __declspec(dllimport) int __cdecl _resetstkoflw(void);

    
    
    

    
        
    

#line 85 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"

    static_assert((sizeof(unsigned int) <= 16), "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 + 16;
        }
        return _Ptr;
    }

    __inline size_t _MallocaComputeSize(size_t _Size)
    {
        size_t _MarkedSize = _Size + 16;
        return _MarkedSize > _Size ? _MarkedSize : 0;
    }

    #pragma warning(pop)

#line 112 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"






    
        
        




    #line 126 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"












#line 139 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"




#line 144 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"
#line 145 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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 - 16;
            _Marker = *(unsigned int*)_Memory;
            if (_Marker == 0xDDDD)
            {
                free(_Memory);
            }
            
            else if (_Marker != 0xCCCC)
            {
                (void)( (!!((("Corrupted pointer passed to _freea" && 0)))) || (1 != _CrtDbgReportW(2, L"C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h", 164, 0, L"%ls", L"(\"Corrupted pointer passed to _freea\" && 0)")) || (__debugbreak(), 0) );
            }
            #line 167 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"
        }
    }
    #pragma warning(pop)

#line 172 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"




    
#line 178 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\malloc.h"
#pragma external_header(pop)
#line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_exception.h"







#pragma once

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"







#pragma once



#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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(dllimport) __declspec(noreturn) void __cdecl abort();
    __declspec(dllimport) __declspec(noreturn) void __cdecl terminate() throw();

    

        __declspec(dllimport) terminate_handler __cdecl set_terminate(
              terminate_handler _NewTerminateHandler
            ) throw();

        __declspec(dllimport) terminate_handler __cdecl _get_terminate();

    #line 44 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_terminate.h"

#line 46 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_terminate.h"

} __pragma(pack(pop))

#line 50 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_terminate.h"

#pragma warning(pop) 
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

    




    
         __declspec(noreturn) void __cdecl unexpected() noexcept(false);

        
             unexpected_handler __cdecl set_unexpected(
                  unexpected_handler _NewUnexpectedHandler
                ) noexcept;
             unexpected_handler __cdecl _get_unexpected() noexcept;
        #line 41 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"
    #line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"
#line 43 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"

struct _EXCEPTION_POINTERS;


    
        typedef void (__cdecl* _se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS*);

         _se_translator_function __cdecl _set_se_translator(
              _se_translator_function _NewSETranslator
            );
    #line 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"

    extern "C++" { 
        class type_info;
    } 

     int __cdecl _is_exception_typeof(
          type_info const&     _Type,
          _EXCEPTION_POINTERS* _ExceptionPtr
        );

     bool __cdecl __uncaught_exception();
     int  __cdecl __uncaught_exceptions();
#line 67 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"

} __pragma(pack(pop))

#pragma warning(pop) 

#line 73 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\eh.h"
#pragma external_header(pop)
#line 11 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_exception.h"
#pragma external_header(pop)
#line 36 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"

namespace std {

 class exception;
 class bad_exception;

 using ::terminate;


 using ::set_terminate;
 using ::terminate_handler;

 [[nodiscard]] inline terminate_handler __cdecl get_terminate() noexcept {
    
    return _get_terminate();
}
#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"













#line 67 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"

}










































































































































#line 208 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"

extern "C++"  void __cdecl __ExceptionPtrCreate(  void*) noexcept;
extern "C++"  void __cdecl __ExceptionPtrDestroy(  void*) noexcept;
extern "C++"  void __cdecl __ExceptionPtrCopy(  void*,   const void*) noexcept;
extern "C++"  void __cdecl __ExceptionPtrAssign(  void*,   const void*) noexcept;
extern "C++"  bool __cdecl __ExceptionPtrCompare(
      const void*,   const void*) noexcept;
extern "C++"  bool __cdecl __ExceptionPtrToBool(  const void*) noexcept;
extern "C++"  void __cdecl __ExceptionPtrSwap(  void*,   void*) noexcept;
extern "C++"  void __cdecl __ExceptionPtrCurrentException(void*) noexcept;
extern "C++" [[noreturn]]  void __cdecl __ExceptionPtrRethrow(  const void*);
extern "C++"  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 302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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& _Arg) {
    
    constexpr bool _Can_use_dynamic_cast =
        is_polymorphic_v<_Ty> && (!is_base_of_v<nested_exception, _Ty> || is_convertible_v<_Ty*, nested_exception*>);

    if constexpr (_Can_use_dynamic_cast) {
        const auto _Nested = dynamic_cast<const nested_exception*>(::std:: addressof(_Arg));

        if (_Nested) {
            _Nested->rethrow_nested();
        }
    }
}



#line 399 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"

 class bad_variant_access
    : public exception { 
public:
    bad_variant_access() noexcept = default;

    [[nodiscard]] const char*  what() const noexcept override {
        return "bad variant access";
    }






#line 415 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"
};

[[noreturn]] inline void _Throw_bad_variant_access() {
    throw bad_variant_access{};
}

}



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

#line 429 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"
#line 430 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\exception"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"


#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_alloc;
 class bad_array_new_length;


#line 85 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"


 struct destroying_delete_t {
    explicit destroying_delete_t() = default;
};
 inline constexpr destroying_delete_t destroying_delete{};
#line 92 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"


 template <class _Ty>
[[nodiscard("'std::launder' has a potential effect on the return value (not on the passed argument). " "It is not useful to call 'std::launder' and discard the return value.")]] constexpr _Ty* launder(_Ty* _Ptr) noexcept {
    static_assert(!is_function_v<_Ty> && !is_void_v<_Ty>,
        "N4950 [ptr.launder]/1: Mandates: !is_function_v<T> && !is_void_v<T> is true.");
    return __builtin_launder(_Ptr);
}


 inline constexpr size_t hardware_constructive_interference_size = 64;
 inline constexpr size_t hardware_destructive_interference_size  = 64;


#line 107 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"

#line 109 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"

 using new_handler = void(__cdecl*)();

 extern "C++"  new_handler __cdecl set_new_handler(  new_handler) noexcept;
 extern "C++" [[nodiscard]]  new_handler __cdecl get_new_handler() noexcept;
}



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

#line 122 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"
#line 123 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\new"
#pragma external_header(pop)
#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 37 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic.h"












#line 50 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic.h"











#line 62 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic.h"




#line 67 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 103 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic.h"
#line 128 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic.h"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"





#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_iter_core.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    )




namespace std {
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{};

 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;


 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>
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>
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_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&;
};

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 <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 _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>>;
    };


 struct default_sentinel_t {};

 inline constexpr default_sentinel_t default_sentinel{};

namespace ranges {
     enum class subrange_kind : bool { unsized, sized };

     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 <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);

     template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
        requires (_Idx < 2)
    [[nodiscard]] constexpr auto get(subrange<_It, _Se, _Ki>&& _Val);
} 

 using ranges::get;

template <class _It, class _Se, ranges::subrange_kind _Ki>
inline constexpr bool _Is_subrange_v<ranges::subrange<_It, _Se, _Ki>> = true;

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;
};

































#line 514 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_iter_core.hpp"
}



#pragma warning(pop)
#pragma pack(pop)
#line 521 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_iter_core.hpp"
#line 522 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_iter_core.hpp"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstring"





#pragma once





#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"







#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {



 
__declspec(dllimport) int __cdecl _memicmp(
      void const* _Buf1,
      void const* _Buf2,
                             size_t      _Size
    );

 
__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_memory.h"

    












#line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_memory.h"

#line 77 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) int __cdecl memicmp(
          void const* _Buf1,
          void const* _Buf2,
                                 size_t      _Size
        );

#line 98 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\corecrt_memory.h"



} __pragma(pack(pop))

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

#pragma warning(pop) 
#pragma external_header(pop)
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {







    
    __declspec(dllimport) errno_t __cdecl strcpy_s(
          char*       _Destination,
                                  rsize_t     _SizeInBytes,
                                char const* _Source
        );

    
    __declspec(dllimport) errno_t __cdecl strcat_s(
          char*       _Destination,
                                     rsize_t     _SizeInBytes,
                                   char const* _Source
        );

    
    __declspec(dllimport) errno_t __cdecl strerror_s(
          char*  _Buffer,
                                  size_t _SizeInBytes,
                                  int    _ErrorNumber);

    
    __declspec(dllimport) errno_t __cdecl strncat_s(
          char*       _Destination,
                                     rsize_t     _SizeInBytes,
               char const* _Source,
                                     rsize_t     _MaxCount
        );

    
    __declspec(dllimport) errno_t __cdecl strncpy_s(
          char*       _Destination,
                                  rsize_t     _SizeInBytes,
            char const* _Source,
                                  rsize_t     _MaxCount
        );

     
    __declspec(dllimport) char*  __cdecl strtok_s(
                          char*       _String,
                                 char const* _Delimiter,
            char**      _Context
        );

#line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

__declspec(dllimport) 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.22621.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.22621.0\\ucrt\\string.h"

#line 98 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

 
int __cdecl strcmp(
      char const* _Str1,
      char const* _Str2
    );

 
__declspec(dllimport) int __cdecl _strcmpi(
      char const* _String1,
      char const* _String2
    );

 
__declspec(dllimport) int __cdecl strcoll(
      char const* _String1,
      char const* _String2
    );

 
__declspec(dllimport) 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.22621.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.22621.0\\ucrt\\string.h"

 
__declspec(dllimport) size_t __cdecl strcspn(
      char const* _Str,
      char const* _Control
    );




#line 146 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

 
__declspec(dllimport) __declspec(allocator) char* __cdecl _strdup(
      char const* _Source
    );



#line 155 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
__declspec(dllimport) char*  __cdecl _strerror(
      char const* _ErrorMessage
    );


__declspec(dllimport) 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.22621.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."))
__declspec(dllimport) 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.22621.0\\ucrt\\string.h"

 
__declspec(dllimport) int __cdecl _stricmp(
      char const* _String1,
      char const* _String2
    );

 
__declspec(dllimport) int __cdecl _stricoll(
      char const* _String1,
      char const* _String2
    );

 
__declspec(dllimport) int __cdecl _stricoll_l(
        char const* _String1,
        char const* _String2,
      _locale_t   _Locale
    );

 
__declspec(dllimport) int __cdecl _stricmp_l(
        char const* _String1,
        char const* _String2,
      _locale_t   _Locale
    );

 
size_t __cdecl strlen(
      char const* _Str
    );


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _strlwr( char *_String);
#line 234 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _strlwr_l(  char *_String,   _locale_t _Locale);
#line 254 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.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.")) __declspec(dllimport) char* __cdecl strncat(  char *_Destination,   char const* _Source,   size_t _Count);
#line 269 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

 
__declspec(dllimport) int __cdecl strncmp(
      char const* _Str1,
      char const* _Str2,
                            size_t      _MaxCount
    );

 
__declspec(dllimport) int __cdecl _strnicmp(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount
    );

 
__declspec(dllimport) int __cdecl _strnicmp_l(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount,
                        _locale_t   _Locale
    );

 
__declspec(dllimport) int __cdecl _strnicoll(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount
    );

 
__declspec(dllimport) int __cdecl _strnicoll_l(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount,
                        _locale_t   _Locale
    );

 
__declspec(dllimport) int __cdecl _strncoll(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount
    );

 
__declspec(dllimport) int __cdecl _strncoll_l(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount,
                        _locale_t   _Locale
    );

__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl strncpy(    char *_Destination,   char const* _Source,   size_t _Count);
#line 341 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

 

#line 347 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

#line 351 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"
__declspec(dllimport) size_t __cdecl strnlen(
      char const* _String,
                            size_t      _MaxCount
    );



     
    
#line 363 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"
    
#line 367 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.22621.0\\ucrt\\string.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _strnset(  char *_Destination,   int _Value,   size_t _Count);
#line 399 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

 
__declspec(dllimport) char const* __cdecl strpbrk(
      char const* _Str,
      char const* _Control
    );

__declspec(dllimport) char* __cdecl _strrev(
      char* _Str
    );


__declspec(dllimport) 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.22621.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.22621.0\\ucrt\\string.h"

 
__declspec(dllimport) 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."))
__declspec(dllimport) char* __cdecl strtok(
      char*       _String,
             char const* _Delimiter
    );


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _strupr( char *_String);
#line 456 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"


__declspec(dllimport) 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.22621.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.")) __declspec(dllimport) char* __cdecl _strupr_l(  char *_String,   _locale_t _Locale);
#line 476 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"

 

__declspec(dllimport) size_t __cdecl strxfrm(
        char*       _Destination,
                                         char const* _Source,
                 size_t      _MaxCount
    );

 

__declspec(dllimport) 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.22621.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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) char* __cdecl strupr(
          char* _String
        );

#line 585 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 592 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"
#line 593 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\string.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstring"
#line 59 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cstring"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"


#line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"






#line 49 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

__declspec(noalias) size_t
    __stdcall __std_count_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
__declspec(noalias) size_t
    __stdcall __std_count_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
__declspec(noalias) size_t
    __stdcall __std_count_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
__declspec(noalias) size_t
    __stdcall __std_count_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;

const void* __stdcall __std_find_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
const void* __stdcall __std_find_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
const void* __stdcall __std_find_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
const void* __stdcall __std_find_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;

const void* __stdcall __std_find_trivial_unsized_1(const void* _First, uint8_t _Val) noexcept;
const void* __stdcall __std_find_trivial_unsized_2(const void* _First, uint16_t _Val) noexcept;
const void* __stdcall __std_find_trivial_unsized_4(const void* _First, uint32_t _Val) noexcept;
const void* __stdcall __std_find_trivial_unsized_8(const void* _First, uint64_t _Val) noexcept;

const void* __stdcall __std_min_element_1(const void* _First, const void* _Last, bool _Signed) noexcept;
const void* __stdcall __std_min_element_2(const void* _First, const void* _Last, bool _Signed) noexcept;
const void* __stdcall __std_min_element_4(const void* _First, const void* _Last, bool _Signed) noexcept;
const void* __stdcall __std_min_element_8(const void* _First, const void* _Last, bool _Signed) noexcept;

const void* __stdcall __std_max_element_1(const void* _First, const void* _Last, bool _Signed) noexcept;
const void* __stdcall __std_max_element_2(const void* _First, const void* _Last, bool _Signed) noexcept;
const void* __stdcall __std_max_element_4(const void* _First, const void* _Last, bool _Signed) noexcept;
const void* __stdcall __std_max_element_8(const void* _First, const void* _Last, bool _Signed) noexcept;
}

template <class _Ty, class _TVal>
__declspec(noalias) size_t __std_count_trivial(_Ty* _First, _Ty* _Last, const _TVal _Val) noexcept {
    if constexpr (::std:: is_pointer_v<_TVal> || ::std:: is_null_pointer_v<_TVal>) {
        return __std_count_trivial(_First, _Last, reinterpret_cast<uintptr_t>(_Val));
    } else if constexpr (sizeof(_Ty) == 1) {
        return __std_count_trivial_1(_First, _Last, static_cast<uint8_t>(_Val));
    } else if constexpr (sizeof(_Ty) == 2) {
        return __std_count_trivial_2(_First, _Last, static_cast<uint16_t>(_Val));
    } else if constexpr (sizeof(_Ty) == 4) {
        return __std_count_trivial_4(_First, _Last, static_cast<uint32_t>(_Val));
    } else if constexpr (sizeof(_Ty) == 8) {
        return __std_count_trivial_8(_First, _Last, static_cast<uint64_t>(_Val));
    } else {
        static_assert(::std:: _Always_false<_Ty>, "Unexpected size");
    }
}

template <class _Ty, class _TVal>
_Ty* __std_find_trivial(_Ty* _First, _Ty* _Last, const _TVal _Val) noexcept {
    if constexpr (::std:: is_pointer_v<_TVal> || ::std:: is_null_pointer_v<_TVal>) {
        return __std_find_trivial(_First, _Last, reinterpret_cast<uintptr_t>(_Val));
    } else if constexpr (sizeof(_Ty) == 1) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_1(_First, _Last, static_cast<uint8_t>(_Val))));
    } else if constexpr (sizeof(_Ty) == 2) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_2(_First, _Last, static_cast<uint16_t>(_Val))));
    } else if constexpr (sizeof(_Ty) == 4) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_4(_First, _Last, static_cast<uint32_t>(_Val))));
    } else if constexpr (sizeof(_Ty) == 8) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_8(_First, _Last, static_cast<uint64_t>(_Val))));
    } else {
        static_assert(::std:: _Always_false<_Ty>, "Unexpected size");
    }
}

template <class _Ty, class _TVal>
_Ty* __std_find_trivial_unsized(_Ty* _First, const _TVal _Val) noexcept {
    if constexpr (::std:: is_pointer_v<_TVal> || ::std:: is_null_pointer_v<_TVal>) {
        return __std_find_trivial_unsized(_First, reinterpret_cast<uintptr_t>(_Val));
    } else if constexpr (sizeof(_Ty) == 1) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_unsized_1(_First, static_cast<uint8_t>(_Val))));
    } else if constexpr (sizeof(_Ty) == 2) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_unsized_2(_First, static_cast<uint16_t>(_Val))));
    } else if constexpr (sizeof(_Ty) == 4) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_unsized_4(_First, static_cast<uint32_t>(_Val))));
    } else if constexpr (sizeof(_Ty) == 8) {
        return const_cast<_Ty*>(
            static_cast<const _Ty*>(__std_find_trivial_unsized_8(_First, static_cast<uint64_t>(_Val))));
    } else {
        static_assert(::std:: _Always_false<_Ty>, "Unexpected size");
    }
}

template <class _Ty>
_Ty* __std_min_element(_Ty* _First, _Ty* _Last) noexcept {
    constexpr bool _Signed = ::std:: is_signed_v<_Ty>;

    if constexpr (sizeof(_Ty) == 1) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_min_element_1(_First, _Last, _Signed)));
    } else if constexpr (sizeof(_Ty) == 2) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_min_element_2(_First, _Last, _Signed)));
    } else if constexpr (sizeof(_Ty) == 4) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_min_element_4(_First, _Last, _Signed)));
    } else if constexpr (sizeof(_Ty) == 8) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_min_element_8(_First, _Last, _Signed)));
    } else {
        static_assert(::std:: _Always_false<_Ty>, "Unexpected size");
    }
}

template <class _Ty>
_Ty* __std_max_element(_Ty* _First, _Ty* _Last) noexcept {
    constexpr bool _Signed = ::std:: is_signed_v<_Ty>;

    if constexpr (sizeof(_Ty) == 1) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_max_element_1(_First, _Last, _Signed)));
    } else if constexpr (sizeof(_Ty) == 2) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_max_element_2(_First, _Last, _Signed)));
    } else if constexpr (sizeof(_Ty) == 4) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_max_element_4(_First, _Last, _Signed)));
    } else if constexpr (sizeof(_Ty) == 8) {
        return const_cast<_Ty*>(static_cast<const _Ty*>(__std_max_element_8(_First, _Last, _Signed)));
    } else {
        static_assert(::std:: _Always_false<_Ty>, "Unexpected size");
    }
}

#line 190 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

namespace std {

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_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 _Ty, class... _Types,
    void_t<decltype(::new(static_cast<void*>(::std:: declval<_Ty*>())) _Ty(::std:: declval<_Types>()...))>* = nullptr>
#line 239 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
    noexcept(::new(static_cast<void*>(_Location)) _Ty(::std:: forward<_Types>(_Args)...)))  {
    [[msvc::constexpr]] return ::new (static_cast<void*>(_Location)) _Ty(::std:: forward<_Types>(_Args)...);
}
#line 244 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 253 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    {
        ::new (static_cast<void*>(::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 (static_cast<void*>(::std:: addressof(_Obj))) _Ty;
}

template <class _Ty, class _Elem>
struct _Ptr_traits_base {
    using pointer         = _Ty;
    using element_type    = _Elem;
    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<_Elem>, char, _Elem>&;

    [[nodiscard]] static constexpr pointer pointer_to(_Reftype _Val) noexcept(
        noexcept(_Ty::pointer_to(_Val)))  { 
        return _Ty::pointer_to(_Val);
    }
};

template <class, class = void, class = void>
struct _Ptr_traits_sfinae_layer {};

template <class _Ty, class _Uty>
struct _Ptr_traits_sfinae_layer<_Ty, _Uty, void_t<typename _Get_first_parameter<_Ty>::type>>
    : _Ptr_traits_base<_Ty, typename _Get_first_parameter<_Ty>::type> {};

template <class _Ty>
struct _Ptr_traits_sfinae_layer<_Ty, void_t<typename _Ty::element_type>, void>
    : _Ptr_traits_base<_Ty, typename _Ty::element_type> {};

 template <class _Ty>
struct pointer_traits : _Ptr_traits_sfinae_layer<_Ty> {};

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 325 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Ty>
[[nodiscard]] constexpr _Ty* to_address(_Ty* const _Val) noexcept {
    static_assert(!is_function_v<_Ty>, "N4950 [pointer.conversion]/1: Mandates: T is not 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 350 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Ty = void>
struct plus {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left + _Right;
    }
};

 template <class _Ty = void>
struct minus {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left - _Right;
    }
};

 template <class _Ty = void>
struct multiplies {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left * _Right;
    }
};

 template <class _Ty = void>
struct equal_to {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left == _Right)))  {
        return _Left == _Right;
    }
};

 template <class _Ty = void>
struct not_equal_to {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left != _Right)))  {
        return _Left != _Right;
    }
};

 template <class _Ty = void>
struct greater {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left > _Right)))  {
        return _Left > _Right;
    }
};

 template <class _Ty = void>
struct greater_equal {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left >= _Right)))  {
        return _Left >= _Right;
    }
};

 template <class _Ty = void>
struct less_equal {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        noexcept(noexcept(_Fake_copy_init<bool>(_Left <= _Right)))  {
        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 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 _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>
[[nodiscard]] constexpr auto _Pass_fn(_Fn& _Func) noexcept {
    constexpr bool _Pass_by_value = conjunction_v<bool_constant<sizeof(_Fn) <= sizeof(void*)>,
        is_trivially_copy_constructible<_Fn>, is_trivially_destructible<_Fn>>;
    if constexpr (_Pass_by_value) {
        return _Func;
    } else {
        return _Ref_fn<_Fn>{_Func}; 
    }
}












#line 577 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

struct _Unused_parameter { 
    constexpr _Unused_parameter() noexcept = default;
    template <class _Ty>
    constexpr _Unused_parameter(_Ty&&) noexcept {}
};

template <class _Ty>
using _Algorithm_int_t = conditional_t<is_integral_v<_Ty>, _Ty, ptrdiff_t>;


template <class _Ty>
concept _Destructible_object = is_object_v<_Ty> && destructible<_Ty>;

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) {
    ::std:: _Derived_from_specialization_impl<_Template>(_Obj); 
};

namespace ranges {
    namespace _Iter_move {


#line 604 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        void iter_move();
#line 606 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        
        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 <class _Ty>
struct _Indirect_value_impl {
    using type = iter_value_t<_Ty>&;
};

template <indirectly_readable _It>
using _Indirect_value_t = typename _Indirect_value_impl<_It>::type;

 template <indirectly_readable _Ty>
using iter_common_reference_t = common_reference_t<iter_reference_t<_Ty>, _Indirect_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 <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 <class _Ty>
concept incrementable = regular<_Ty> && weakly_incrementable<_Ty> && requires(_Ty __t) {
    { __t++ } -> same_as<_Ty>;
};

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&, _Indirect_value_t<_It>>
    && invocable<_Fn&, iter_reference_t<_It>> && invocable<_Fn&, iter_common_reference_t<_It>>
    && common_reference_with<invoke_result_t<_Fn&, _Indirect_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&, _Indirect_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&, _Indirect_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&, _Indirect_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&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
                                 && predicate<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
                                 && predicate<_Fn&, iter_reference_t<_It1>, _Indirect_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&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
    && equivalence_relation<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
    && equivalence_relation<_Fn&, iter_reference_t<_It1>, _Indirect_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&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
    && strict_weak_order<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
    && strict_weak_order<_Fn&, iter_reference_t<_It1>, _Indirect_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>...>;

template <class _It>
struct _Projected_difference_type_impl {
    struct _Base {};
};

template <weakly_incrementable _It>
struct _Projected_difference_type_impl<_It> {
    struct _Base {
        using difference_type = iter_difference_t<_It>;
    };
};

template <class _It, class _Proj>
struct _Projected_impl {
    struct _Type : _Projected_difference_type_impl<_It>::_Base {
        using _Iterator   = _It;
        using _Projection = _Proj;

        using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
        indirect_result_t<_Proj&, _It> operator*() const {
            :: abort();
        }
    };
};

 template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
using projected = _Projected_impl<_It, _Proj>::_Type;

template <class _Ty>
concept _Projected_specialization = same_as<_Ty, projected<typename _Ty::_Iterator, typename _Ty::_Projection>>;

template <_Projected_specialization _ProjTy>
struct _Indirect_value_impl<_ProjTy> {
    using type = invoke_result_t<typename _ProjTy::_Projection&, _Indirect_value_t<typename _ProjTy::_Iterator>>;
};

 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_swap::_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_swap::_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 1061 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_cpp17_input_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, input_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_ranges_input_iter_v =

    (input_iterator<_Iter> && sentinel_for<_Iter, _Iter>) ||
#line 1085 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    _Is_cpp17_input_iter_v<_Iter>;

template <class _Iter>
inline constexpr bool _Is_cpp17_fwd_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, forward_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_ranges_fwd_iter_v =

    forward_iterator<_Iter> ||
#line 1095 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    _Is_cpp17_fwd_iter_v<_Iter>;

template <class _Iter>
inline constexpr bool _Is_cpp17_bidi_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, bidirectional_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_ranges_bidi_iter_v =

    bidirectional_iterator<_Iter> ||
#line 1105 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    _Is_cpp17_bidi_iter_v<_Iter>;

template <class _Iter>
inline constexpr bool _Is_cpp17_random_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, random_access_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_ranges_random_iter_v =

    random_access_iterator<_Iter> ||
#line 1115 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    _Is_cpp17_random_iter_v<_Iter>;





template <class, class = void>
struct _Is_checked_helper {}; 


template <class _Ty>
constexpr void _Verify_range(const _Ty* const _First, const _Ty* const _Last) noexcept {
    
    do { if (_First <= _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1128, 0, "%s", "transposed pointer range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"transposed pointer range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1128, 0); } while (false); } ; } while (false);
}
#line 1131 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, class = void>
inline constexpr bool _Has_nothrow_unwrapped = false;
template <class _Iter>
inline constexpr bool _Has_nothrow_unwrapped<_Iter, void_t<decltype(::std:: declval<_Iter>()._Unwrapped())>> =
    noexcept(::std:: declval<_Iter>()._Unwrapped());

template <class _Iter>
[[nodiscard]] constexpr decltype(auto) _Get_unwrapped(_Iter&& _It) noexcept(
    !_Unwrappable_v<_Iter> || _Has_nothrow_unwrapped<_Iter>) {
    
    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_like_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);

        do { if (_COff <= static_cast<_CDiff>(_Max_possible_v<_IDiff>) && (is_unsigned_v<_Diff> || static_cast<_CDiff>(_Min_possible_v<_IDiff>) <= _COff)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1248, 0, "%s", "integer overflow")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"integer overflow\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1248, 0); } while (false); } ; } while (false);
#line 1249 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 =


#line 1294 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;
#line 1296 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _Iter>
using _Guide_val_t =


#line 1302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    typename iterator_traits<_Iter>::value_type::second_type;
#line 1304 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _Iter>
using _Guide_pair_t =



#line 1311 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
        typename iterator_traits<_Iter>::value_type::second_type>;
#line 1314 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 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 1330 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _Checked, class _Iter>
[[nodiscard]] constexpr auto _Idl_distance(const _Iter& _First, const _Iter& _Last) {
    
    if constexpr (_Is_ranges_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 1360 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"





template <class _Pr, class _Ty1, class _Ty2,
    enable_if_t<is_same_v<_Remove_cvref_t<_Ty1>, _Remove_cvref_t<_Ty2>>, int> = 0>
constexpr bool _Debug_lt_pred(_Pr&& _Pred, _Ty1&& _Left, _Ty2&& _Right) noexcept(
    noexcept(_Pred(_Left, _Right)) && noexcept(_Pred(_Right, _Left))) {
    
    const auto _Result = static_cast<bool>(_Pred(_Left, _Right));
    if (_Result) {
        do { if (!_Pred(_Right, _Left)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1372, 0, "%s", "invalid comparator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid comparator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1372, 0); } while (false); } ; } while (false);
    }

    return _Result;
}

template <class _Pr, class _Ty1, class _Ty2,
    enable_if_t<!is_same_v<_Remove_cvref_t<_Ty1>, _Remove_cvref_t<_Ty2>>, int> = 0>
constexpr bool _Debug_lt_pred(_Pr&& _Pred, _Ty1&& _Left, _Ty2&& _Right) noexcept(noexcept(_Pred(_Left, _Right))) {
    
    return static_cast<bool>(_Pred(_Left, _Right));
}

template <class _InIt, class _Sentinel, class _Pr>
constexpr void _Debug_order_unchecked(_InIt _First, _Sentinel _Last, _Pr&& _Pred) {
    
    if constexpr (_Is_ranges_fwd_iter_v<_InIt>) {
        if (_First != _Last) {
            for (auto _Next = _First; ++_Next != _Last; _First = _Next) {
                do { if (!static_cast<bool>(_Pred(*_Next, *_First))) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1391, 0, "%s", "sequence not ordered")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"sequence not ordered\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1391, 0); } while (false); } ; } while (false);
            }
        }
    }
}

template <class _OtherIt, class _InIt, class _Pr>
constexpr void _Debug_order_set_unchecked(_InIt _First, _InIt _Last, _Pr&& _Pred) {
    
    if constexpr (is_same_v<_Iter_value_t<_OtherIt>, _Iter_value_t<_InIt>>) {
        _Debug_order_unchecked(_First, _Last, _Pred);
    }
}
#line 1405 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"


 template <class _InIt, class _Diff>
constexpr void advance(_InIt& _Where, _Diff _Off) { 
    if constexpr (_Is_ranges_random_iter_v<_InIt>) {
        _Where += _Off;
    } else {
        if constexpr (is_signed_v<_Diff> && !_Is_ranges_bidi_iter_v<_InIt>) {
            do { if (_Off >= 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1413, 0, "%s", "negative advance of non-bidirectional iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"negative advance of non-bidirectional iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1413, 0); } while (false); } ; } while (false);
        }

        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_ranges_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_ranges_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_ranges_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_ranges_bidi_iter_v<_BidIt>, "prev requires bidirectional iterator");

    ::std:: advance(_First, -_Off);
    return _First;
}

template <class _Iter, class _Pointer, bool = is_pointer_v<_Remove_cvref_t<_Iter>>>
inline constexpr bool _Has_nothrow_operator_arrow = _Is_nothrow_convertible_v<_Iter, _Pointer>;

template <class _Iter, class _Pointer>
inline constexpr bool _Has_nothrow_operator_arrow<_Iter, _Pointer, false> =
    noexcept(_Fake_copy_init<_Pointer>(::std:: declval<_Iter>().operator->()));

 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 1498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1517 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1526 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    constexpr reverse_iterator& operator=(const reverse_iterator<_Other>& _Right) noexcept(
        is_nothrow_assignable_v<_BidIt&, const _Other&>)  {
        current = _Right.current;
        return *this;
    }
    

    [[nodiscard]] constexpr _BidIt base() const noexcept(is_nothrow_copy_constructible_v<_BidIt>)  {
        return current;
    }

    [[nodiscard]] constexpr reference operator*() const
        noexcept(is_nothrow_copy_constructible_v<_BidIt>&& noexcept(*--(::std:: declval<_BidIt&>())))  {
        _BidIt _Tmp = current;
        return *--_Tmp;
    }

    [[nodiscard]] constexpr pointer operator->() const
        noexcept(is_nothrow_copy_constructible_v<_BidIt>&& noexcept(--(::std:: declval<_BidIt&>()))
                 && _Has_nothrow_operator_arrow<_BidIt&, pointer>) 

        requires (is_pointer_v<_BidIt> || requires(const _BidIt __i) { __i.operator->(); })
#line 1549 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    {
        _BidIt _Tmp = current;
        --_Tmp;
        if constexpr (is_pointer_v<_BidIt>) {
            return _Tmp;
        } else {
            return _Tmp.operator->();
        }
    }

    constexpr reverse_iterator& operator++() noexcept(noexcept(--current))  {
        --current;
        return *this;
    }

    constexpr reverse_iterator operator++(int) noexcept(
        is_nothrow_copy_constructible_v<_BidIt>&& noexcept(--current))  {
        reverse_iterator _Tmp = *this;
        --current;
        return _Tmp;
    }

    constexpr reverse_iterator& operator--() noexcept(noexcept(++current))  {
        ++current;
        return *this;
    }

    constexpr reverse_iterator operator--(int) noexcept(
        is_nothrow_copy_constructible_v<_BidIt>&& noexcept(++current))  {
        reverse_iterator _Tmp = *this;
        ++current;
        return _Tmp;
    }

    [[nodiscard]] constexpr reverse_iterator operator+(const difference_type _Off) const
        noexcept(noexcept(reverse_iterator(current - _Off)))  {
        return reverse_iterator(current - _Off);
    }

    constexpr reverse_iterator& operator+=(const difference_type _Off) noexcept(
        noexcept(current -= _Off))  {
        current -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr reverse_iterator operator-(const difference_type _Off) const
        noexcept(noexcept(reverse_iterator(current + _Off)))  {
        return reverse_iterator(current + _Off);
    }

    constexpr reverse_iterator& operator-=(const difference_type _Off) noexcept(
        noexcept(current += _Off))  {
        current += _Off;
        return *this;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const
        noexcept(noexcept(_Fake_copy_init<reference>(current[_Off])))  {
        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 1629 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept {
        _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 noexcept {
        do { if (_Off != _Min_possible_v<difference_type>) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1640, 0, "%s", "integer overflow")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"integer overflow\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 1640, 0); } 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& noexcept(
        noexcept(static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped()))) {
        return static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped());
    }
    template <class _BidIt2 = _BidIt, enable_if_t<_Unwrappable_v<_BidIt2>, int> = 0>
    [[nodiscard]] constexpr reverse_iterator<_Unwrapped_t<_BidIt2>> _Unwrapped() && noexcept(
        noexcept(static_cast<reverse_iterator<_Unwrapped_t<_BidIt2>>>(::std:: move(current)._Unwrapped()))) {
        return static_cast<reverse_iterator<_Unwrapped_t<_BidIt2>>>(::std:: move(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) noexcept(noexcept(current._Seek_to(_It.current))) {
        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) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left._Get_current() == _Right._Get_current()))) 

    
    requires requires {
        { _Left._Get_current() == _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1681 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left._Get_current() != _Right._Get_current()))) 

    
    requires requires {
        { _Left._Get_current() != _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1696 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left._Get_current() > _Right._Get_current()))) 

    
    requires requires {
        { _Left._Get_current() > _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1711 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left._Get_current() < _Right._Get_current()))) 

    
    requires requires {
        { _Left._Get_current() < _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1726 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left._Get_current() >= _Right._Get_current()))) 

    
    requires requires {
        { _Left._Get_current() >= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1741 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left._Get_current() <= _Right._Get_current()))) 

    
    requires requires {
        { _Left._Get_current() <= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1756 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        noexcept(_Right._Get_current() <=> _Left._Get_current()))  {
    return _Right._Get_current() <=> _Left._Get_current();
}
#line 1768 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr auto
    operator-(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
        noexcept(_Right._Get_current() - _Left._Get_current())) 
    -> 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) noexcept(noexcept(_Right + _Off))  {
    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 1794 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Container>
[[nodiscard]] constexpr auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) 
    -> decltype(_Cont.begin()) {
    return _Cont.begin();
}

 template <class _Container>
[[nodiscard]] constexpr auto begin(const _Container& _Cont) noexcept(noexcept(_Cont.begin())) 
    -> decltype(_Cont.begin()) {
    return _Cont.begin();
}

 template <class _Container>
[[nodiscard]] constexpr auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) 
    -> decltype(_Cont.end()) {
    return _Cont.end();
}

 template <class _Container>
[[nodiscard]] constexpr auto end(const _Container& _Cont) noexcept(noexcept(_Cont.end())) 
    -> 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) noexcept(noexcept(_Cont.rbegin())) 
    -> decltype(_Cont.rbegin()) {
    return _Cont.rbegin();
}

 template <class _Container>
[[nodiscard]] constexpr auto rbegin(const _Container& _Cont) noexcept(noexcept(_Cont.rbegin())) 
    -> decltype(_Cont.rbegin()) {
    return _Cont.rbegin();
}

 template <class _Container>
[[nodiscard]] constexpr auto rend(_Container& _Cont) noexcept(noexcept(_Cont.rend())) 
    -> decltype(_Cont.rend()) {
    return _Cont.rend();
}

 template <class _Container>
[[nodiscard]] constexpr auto rend(const _Container& _Cont) noexcept(noexcept(_Cont.rend())) 
    -> decltype(_Cont.rend()) {
    return _Cont.rend();
}

 template <class _Ty, size_t _Size>
[[nodiscard]] constexpr reverse_iterator<_Ty*> rbegin(_Ty (&_Array)[_Size]) noexcept  {
    return reverse_iterator<_Ty*>(_Array + _Size);
}

 template <class _Ty, size_t _Size>
[[nodiscard]] constexpr reverse_iterator<_Ty*> rend(_Ty (&_Array)[_Size]) noexcept  {
    return reverse_iterator<_Ty*>(_Array);
}

 template <class _Elem>
[[nodiscard]] constexpr reverse_iterator<const _Elem*> rbegin(initializer_list<_Elem> _Ilist) noexcept
 {
    return reverse_iterator<const _Elem*>(_Ilist.end());
}

 template <class _Elem>
[[nodiscard]] constexpr reverse_iterator<const _Elem*> rend(initializer_list<_Elem> _Ilist) noexcept
 {
    return reverse_iterator<const _Elem*>(_Ilist.begin());
}

 template <class _Container>
[[nodiscard]] constexpr auto crbegin(const _Container& _Cont) noexcept(noexcept(::std:: rbegin(_Cont))) 
    -> decltype(::std:: rbegin(_Cont)) {
    return ::std:: rbegin(_Cont);
}

 template <class _Container>
[[nodiscard]] constexpr auto crend(const _Container& _Cont) noexcept(noexcept(::std:: rend(_Cont))) 
    -> decltype(::std:: rend(_Cont)) {
    return ::std:: rend(_Cont);
}

 template <class _Container>
[[nodiscard]] constexpr auto size(const _Container& _Cont) noexcept(noexcept(_Cont.size())) 
    -> 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) noexcept(noexcept(
    static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>>>(_Cont.size()))) 
    -> 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 1924 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Container>
[[nodiscard("This function returns a bool indicating whether the container or container-like object is empty and " "has no other effects. It is not useful to call this function and discard the return value.")]] constexpr auto empty(const _Container& _Cont) noexcept(
    noexcept(_Cont.empty())) 
    -> decltype(_Cont.empty()) {
    return _Cont.empty();
}

 template <class _Ty, size_t _Size>
[[nodiscard("This function returns a bool indicating whether the container or container-like object is empty and " "has no other effects. It is not useful to call this function and discard the return value.")]] constexpr bool empty(const _Ty (&)[_Size]) noexcept {
    return false;
}

 template <class _Elem>
[[nodiscard("This function returns a bool indicating whether the container or container-like object is empty and " "has no other effects. It is not useful to call this function and discard the return value.")]] constexpr bool empty(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.size() == 0;
}

 template <class _Container>
[[nodiscard]] constexpr auto data(_Container& _Cont) noexcept(noexcept(_Cont.data())) 
    -> decltype(_Cont.data()) {
    return _Cont.data();
}

 template <class _Container>
[[nodiscard]] constexpr auto data(const _Container& _Cont) noexcept(noexcept(_Cont.data())) 
    -> 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();
}























































































































































































































































































































































#line 2307 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

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 {


#line 2326 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        void begin();
#line 2328 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_copy_init(__t.begin()) } -> input_or_output_iterator;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_copy_init(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_copy_init(::std:: declval<_Ty>().begin()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_copy_init(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 _End {


#line 2394 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        void end();
#line 2396 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_copy_init(__t.end()) } -> sentinel_for<iterator_t<_Ty>>;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_copy_init(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_copy_init(::std:: declval<_Ty>().end()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_copy_init(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;
    }

     template <class _Rng>
    concept range = requires(_Rng& __r) {
        ::std::ranges:: begin(__r);
        ::std::ranges:: end(__r);
    };

     template <class _Rng>
    concept input_range = range<_Rng> && input_iterator<iterator_t<_Rng>>;

     template <range _Rng>
    using sentinel_t = decltype(::std::ranges:: end(::std:: declval<_Rng&>()));

    template <class _Wrapped>
    concept _Weakly_unwrappable = _Allow_inheriting_unwrap_v<remove_cvref_t<_Wrapped>>
                               && requires(_Wrapped&& _Wr) { ::std:: forward<_Wrapped>(_Wr)._Unwrapped(); };

    template <class _Sent>
    concept _Weakly_unwrappable_sentinel = _Weakly_unwrappable<const remove_reference_t<_Sent>&>;

    template <class _Iter>
    concept _Weakly_unwrappable_iterator =
        _Weakly_unwrappable<_Iter> && requires(_Iter&& _It, remove_cvref_t<_Iter>& _MutIt) {
            _MutIt._Seek_to(::std:: forward<_Iter>(_It)._Unwrapped());
        };

    template <class _Sent, class _Iter>
    concept _Unwrappable_sentinel_for = _Weakly_unwrappable_sentinel<_Sent> && _Weakly_unwrappable_iterator<_Iter>
                                     && requires(_Iter&& _It, const remove_reference_t<_Sent>& _Se) {
                                            {
                                                _Se._Unwrapped()
                                            } -> sentinel_for<decltype(::std:: forward<_Iter>(_It)._Unwrapped())>;
                                        };

    template <class _Sent, class _Iter>
    [[nodiscard]] constexpr decltype(auto) _Unwrap_iter(_Iter&& _It) noexcept(
        !_Unwrappable_sentinel_for<_Sent, _Iter> || _Has_nothrow_unwrapped<_Iter>) {
        ;
        if constexpr (is_pointer_v<remove_cvref_t<_Iter>>) {
            return _It + 0;
        } else if constexpr (_Unwrappable_sentinel_for<_Sent, _Iter>) {
            return static_cast<_Iter&&>(_It)._Unwrapped();
        } else {
            return static_cast<_Iter&&>(_It);
        }
    }

    template <class _Iter, class _Sent>
    [[nodiscard]] constexpr decltype(auto) _Unwrap_sent(_Sent&& _Se) noexcept(
        !_Unwrappable_sentinel_for<_Sent, _Iter> || _Has_nothrow_unwrapped<_Sent>) {
        ;
        if constexpr (is_pointer_v<remove_cvref_t<_Sent>>) {
            return _Se + 0;
        } else if constexpr (_Unwrappable_sentinel_for<_Sent, _Iter>) {
            return static_cast<_Sent&&>(_Se)._Unwrapped();
        } else {
            return static_cast<_Sent&&>(_Se);
        }
    }

    template <range _Rng, class _Iter>
    [[nodiscard]] constexpr decltype(auto) _Unwrap_range_iter(_Iter&& _It) noexcept(
        noexcept(_Unwrap_iter<sentinel_t<_Rng>>(static_cast<_Iter&&>(_It)))) {
        ;
        return _Unwrap_iter<sentinel_t<_Rng>>(static_cast<_Iter&&>(_It));
    }

    template <range _Rng, class _Sent>
    [[nodiscard]] constexpr decltype(auto) _Unwrap_range_sent(_Sent&& _Se) noexcept(
        noexcept(_Unwrap_sent<iterator_t<_Rng>>(static_cast<_Sent&&>(_Se)))) {
        ;
        return _Unwrap_sent<iterator_t<_Rng>>(static_cast<_Sent&&>(_Se));
    }

    template <class _Iter, class _Sent>
    using _Unwrap_iter_t = remove_cvref_t<decltype(_Unwrap_iter<_Sent>(::std:: declval<_Iter>()))>;
    template <class _Sent, class _Iter>
    using _Unwrap_sent_t = remove_cvref_t<decltype(_Unwrap_sent<_Iter>(::std:: declval<_Sent>()))>;

    template <range _Rng>
    using _Unwrapped_iterator_t = _Unwrap_iter_t<iterator_t<_Rng>, sentinel_t<_Rng>>;
    template <range _Rng>
    using _Unwrapped_sentinel_t = _Unwrap_sent_t<sentinel_t<_Rng>, iterator_t<_Rng>>;

    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) { _Unwrap_range_iter<_Ty>(::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 2564 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
                    return {_St::_Member, noexcept(_Fake_copy_init(::std:: declval<_Ty>()._Unchecked_begin()))};
                } else if constexpr (_Can_begin<_Ty>) {
                    return {_St::_Unwrap,
                        noexcept(_Fake_copy_init(_Unwrap_range_iter<_Ty>(::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 _Unwrap_range_iter<_Ty>(::std::ranges:: begin(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "Should be unreachable");
                }
            }
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Unchecked_begin::_Cpo _Ubegin;
    }

    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) { _Unwrap_range_sent<_Ty>(::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>) {
                    return {_St::_Member, noexcept(::std:: declval<_Ty>()._Unchecked_end())};
                } else if constexpr (_Can_end<_Ty>) {
                    return {_St::_Unwrap, noexcept(_Unwrap_range_sent<_Ty>(::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 _Unwrap_range_sent<_Ty>(::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 borrowed_range = range<_Rng> && _Should_range_access<_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>>;

     template <range _Rng>
    using range_common_reference_t = iter_common_reference_t<iterator_t<_Rng>>;


















#line 2683 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    struct _Cbegin_fn {














#line 2700 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        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));
        }
#line 2708 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    };

    inline namespace _Cpos {
         inline constexpr _Cbegin_fn cbegin;
    }

    struct _Cend_fn {














#line 2730 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        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));
        }
#line 2738 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    };

    inline namespace _Cpos {
         inline constexpr _Cend_fn cend;
    }

    namespace _Rbegin {


#line 2748 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        void rbegin();
#line 2750 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_copy_init(__t.rbegin()) } -> input_or_output_iterator;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_copy_init(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_copy_init(::std:: declval<_Ty>().rbegin()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {
                        _St::_Non_member, noexcept(_Fake_copy_init(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 {


#line 2816 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        void rend();
#line 2818 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_copy_init(__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_copy_init(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_copy_init(::std:: declval<_Ty>().rend()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_copy_init(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 {














#line 2897 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        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));
        }
#line 2905 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    };

    inline namespace _Cpos {
         inline constexpr _Crbegin_fn crbegin;
    }

    struct _Crend_fn {














#line 2927 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        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));
        }
#line 2935 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    };

    inline namespace _Cpos {
         inline constexpr _Crend_fn crend;
    }

     template <class>
    inline constexpr bool disable_sized_range = false;

    namespace _Size {


#line 2948 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        void size();
#line 2950 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        template <class _Ty, class _UnCV>
        concept _Has_member = !disable_sized_range<_UnCV> && requires(_Ty __t) {
            { _Fake_copy_init(__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_copy_init(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_copy_init(::std:: declval<_Ty>().size()))};
                } else if constexpr (_Has_ADL<_Ty, _UnCV>) {
                    return {_St::_Non_member, noexcept(_Fake_copy_init(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_copy_init(__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 {









#line 3152 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        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));
        }
#line 3160 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    };

    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 <class _Ty, template <class...> class _Template>
    concept _Strictly_derived_from_specialization_of =
        is_object_v<_Ty> && _Derived_from_specialization_of<_Ty, _Template>;

     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> || _Strictly_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 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>) {
                    do { if (_Off >= 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3241, 0, "%s", "negative advance of non-bidirectional iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"negative advance of non-bidirectional iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3241, 0); } while (false); } ; } while (false);
                }

                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      = _Unwrap_iter<_Se>(static_cast<_It&&>(_Where));
                constexpr bool _Need_rewrap = !is_reference_v<decltype(_Unwrap_iter<_Se>(static_cast<_It&&>(_Where)))>;
                decltype(auto) _ULast       = _Unwrap_sent<_It>(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 {
                    do { if (_Off >= 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3308, 0, "%s", "negative advance of non-bidirectional iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"negative advance of non-bidirectional iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3308, 0); } while (false); } ; } while (false);
                }

                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<_It> _Se>
            requires (!sized_sentinel_for<_Se, _It>)
        [[nodiscard]] constexpr iter_difference_t<_It> operator()(_It _First, _Se _Last) const
            noexcept(noexcept(_Distance_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)))))  {
            _Adl_verify_range(_First, _Last);
            return _Distance_unchecked(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::std:: move(_Last)));
        }

        template <class _It, sized_sentinel_for<decay_t<_It>> _Se>
        [[nodiscard]] constexpr iter_difference_t<decay_t<_It>> operator()(_It&& _First, const _Se _Last) const
            noexcept(noexcept(_Last - static_cast<const decay_t<_It>&>(_First)))  {
            return _Last - static_cast<const decay_t<_It>&>(_First);
        }

        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>
        [[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 {
            do { if (_Off != _Min_possible_v<iter_difference_t<_It>>) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3434, 0, "%s", "integer overflow")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"integer overflow\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3434, 0); } while (false); } ; } while (false);
            ::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 {
            do { if (_Off != _Min_possible_v<iter_difference_t<_It>>) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3441, 0, "%s", "integer overflow")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"integer overflow\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3441, 0); } while (false); } ; } while (false);
            ::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 _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>>;

    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> "
                "(N4950 [view.interface.general]/2).");
            static_assert(view<_Derived>,
                "view_interface's template argument must model the view concept (N4950 [view.interface.general]/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> "
                "(N4950 [view.interface.general]/2).");
            static_assert(view<_Derived>,
                "view_interface's template argument must model the view concept (N4950 [view.interface.general]/2).");
            return static_cast<const _Derived&>(*this);
        }

    public:
        [[nodiscard]] constexpr bool empty()
            requires sized_range<_Derived> || forward_range<_Derived>
        {
            auto& _Self = _Cast();
            if constexpr (sized_range<_Derived>) {
                return ::std::ranges:: size(_Self) == 0;
            } else {
                return ::std::ranges:: begin(_Self) == ::std::ranges:: end(_Self);
            }
        }

        [[nodiscard]] constexpr bool empty() const
            requires sized_range<const _Derived> || forward_range<const _Derived>
        {
            auto& _Self = _Cast();
            if constexpr (sized_range<const _Derived>) {
                return ::std::ranges:: size(_Self) == 0;
            } else {
                return ::std::ranges:: begin(_Self) == ::std::ranges:: end(_Self);
            }
        }

























#line 3581 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        constexpr explicit operator bool()
            requires _Can_empty<_Derived>
        {
            return !::std::ranges:: empty(_Cast());
        }

        constexpr explicit operator bool() const
            requires _Can_empty<const _Derived>
        {
            return !::std::ranges:: empty(_Cast());
        }

        [[nodiscard]] constexpr auto data()
            requires contiguous_iterator<iterator_t<_Derived>>
        {
            return ::std:: to_address(::std::ranges:: begin(_Cast()));
        }

        [[nodiscard]] constexpr auto data() const
            requires range<const _Derived> && contiguous_iterator<iterator_t<const _Derived>>
        {
            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>>
        {
            auto& _Self = _Cast();
            return ::std:: _To_unsigned_like(::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>>
        {
            auto& _Self = _Cast();
            return ::std:: _To_unsigned_like(::std::ranges:: end(_Self) - ::std::ranges:: begin(_Self));
        }

        [[nodiscard]] constexpr decltype(auto) front()
            requires forward_range<_Derived>
        {
            auto& _Self = _Cast();

            do { if (!::std::ranges:: empty(_Self)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3626, 0, "%s", "front called on empty view_interface")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front called on empty view_interface\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3626, 0); } while (false); } ; } while (false);
#line 3628 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            return *::std::ranges:: begin(_Self);
        }

        [[nodiscard]] constexpr decltype(auto) front() const
            requires forward_range<const _Derived>
        {
            auto& _Self = _Cast();

            do { if (!::std::ranges:: empty(_Self)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3636, 0, "%s", "front called on empty view_interface")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front called on empty view_interface\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3636, 0); } while (false); } ; } while (false);
#line 3638 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            return *::std::ranges:: begin(_Self);
        }

        [[nodiscard]] constexpr decltype(auto) back()
            requires bidirectional_range<_Derived> && common_range<_Derived>
        {
            auto& _Self = _Cast();

            do { if (!::std::ranges:: empty(_Self)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3646, 0, "%s", "back called on empty view_interface")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back called on empty view_interface\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3646, 0); } while (false); } ; } while (false);
#line 3648 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            auto _Last = ::std::ranges:: end(_Self);
            return *--_Last;
        }

        [[nodiscard]] constexpr decltype(auto) back() const
            requires bidirectional_range<const _Derived> && common_range<const _Derived>
        {
            auto& _Self = _Cast();

            do { if (!::std::ranges:: empty(_Self)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3657, 0, "%s", "back called on empty view_interface")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back called on empty view_interface\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3657, 0); } while (false); } ; } while (false);
#line 3659 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();

            if constexpr (sized_range<_Derived>) {
                using _U_diff = _Make_unsigned_like_t<range_difference_t<_Rng>>;
                do { if (static_cast<_U_diff>(_Idx) < static_cast<_U_diff>(::std::ranges:: size(_Self))) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3670, 0, "%s", "index out of range for view_interface")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"index out of range for view_interface\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3670, 0); } while (false); } ; } while (false);
#line 3671 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            }
#line 3673 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();

            if constexpr (sized_range<_Derived>) {
                using _U_diff = _Make_unsigned_like_t<range_difference_t<_Rng>>;
                do { if (static_cast<_U_diff>(_Idx) < static_cast<_U_diff>(::std::ranges:: size(_Self))) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3683, 0, "%s", "index out of range for view_interface")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"index out of range for view_interface\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3683, 0); } while (false); } ; } while (false);
#line 3684 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            }
#line 3686 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            return ::std::ranges:: begin(_Self)[_Idx];
        }
    };
} 

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>&>;
    };
#line 3712 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    template <class _Ty, class _First, class _Second>
    concept _Pair_like_convertible_from = !range<_Ty>


#line 3718 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
                                       && _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 <class _It, class _Se, subrange_kind _Ki>
    concept _Store_size = (_Ki == subrange_kind::sized) && !sized_sentinel_for<_Se, _It>;

    template <class _It, class _Se, subrange_kind _Ki>
    class _Subrange_base : public view_interface<subrange<_It, _Se, _Ki>> {
    protected:
        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;

    public:
        _Subrange_base() = default;
        constexpr explicit _Subrange_base(const _Size_type&) noexcept {}
    };

    template <class _It, class _Se, subrange_kind _Ki>
        requires _Store_size<_It, _Se, _Ki>
    class _Subrange_base<_It, _Se, _Ki> : public view_interface<subrange<_It, _Se, _Ki>> {
    protected:
        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;

        _Size_type _Size = 0;

    public:
        _Subrange_base() = default;
        constexpr explicit _Subrange_base(const _Size_type& _Size_) noexcept : _Size(_Size_) {}
    };


#pragma warning(push)
#pragma warning(disable : 4324) 
#line 3752 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
     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 _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;

        
         _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<_It, _Se, _Ki>)
            : _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)
            : _Subrange_base<_It, _Se, _Ki>(_Size_), _First(::std:: move(_First_)), _Last(::std:: move(_Last_)) {
            if constexpr (sized_sentinel_for<_Se, _It>) {
                do { if (_Size_ == static_cast<_Size_type>(_Last - _First)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3793, 0, "%s", "This constructor's third argument should be equal to the distance " "between the first and second arguments (N4950 [range.subrange.ctor]/3).")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"This constructor's third argument should be equal to the distance \" \"between the first and second arguments (N4950 [range.subrange.ctor]/3).\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 3793, 0); } while (false); } ; } while (false);
#line 3794 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            }
        }

        template <_Different_from<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<_It, _Se, _Ki> || sized_range<_Rng>)
            : subrange{bool_constant<_Store_size<_It, _Se, _Ki>>{}, ::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 <_Different_from<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<_It, _Se, _Ki>) {
                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<_It, _Se, _Ki>) {
                    --_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<_It, _Se, _Ki>) {
                    --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<_It, _Se, _Ki>) {
                ++_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<_It, _Se, _Ki>) {
                        this->_Size += static_cast<_Size_type>(-_Count);
                    }
                    return *this;
                }
            }

            const auto _Remainder = ::std::ranges:: advance(_First, _Count, _Last);
            if constexpr (_Store_size<_It, _Se, _Ki>) {
                this->_Size -= static_cast<_Size_type>(_Count - _Remainder);
            }
            return *this;
        }
    };

#pragma warning(pop)
#line 3918 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    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();
        }
    }

     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 3970 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3997 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;


private:
    static constexpr auto _Get_iter_concept() {
        if constexpr (random_access_iterator<_Iter>) {
            return random_access_iterator_tag{};
        } else if constexpr (bidirectional_iterator<_Iter>) {
            return bidirectional_iterator_tag{};
        } else if constexpr (forward_iterator<_Iter>) {
            return forward_iterator_tag{};
        } else {
            return input_iterator_tag{};
        }
    }

public:
    using iterator_concept = decltype(_Get_iter_concept());

    using reference = iter_rvalue_reference_t<_Iter>;



#line 4028 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4039 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4048 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4068 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    [[nodiscard]] constexpr reference operator*() const

        noexcept(noexcept(::std::ranges:: iter_move(_Current)))  {
        return ::std::ranges:: iter_move(_Current);
    }




#line 4079 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress this warning.")]] [[nodiscard]] constexpr pointer operator->() const
        noexcept(is_nothrow_copy_constructible_v<_Iter>)  {
        return _Current;
    }

    constexpr move_iterator& operator++() noexcept(noexcept(++_Current))  {
        ++_Current;
        return *this;
    }

    constexpr auto operator++(int) noexcept(
        is_nothrow_copy_constructible_v<_Iter>&& noexcept(++_Current))  {

        if constexpr (forward_iterator<_Iter>) {
#line 4095 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            move_iterator _Tmp = *this;
            ++_Current;
            return _Tmp;

        } else {
            ++_Current;
        }
#line 4103 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    }

    constexpr move_iterator& operator--() noexcept(noexcept(--_Current))  {
        --_Current;
        return *this;
    }

    constexpr move_iterator operator--(int) noexcept(
        is_nothrow_copy_constructible_v<_Iter>&& noexcept(--_Current))  {
        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
        noexcept(noexcept(move_iterator(_Current + _Off)))  {
        return move_iterator(_Current + _Off);
    }

    constexpr move_iterator& operator+=(const difference_type _Off) noexcept(
        noexcept(_Current += _Off))  {
        _Current += _Off;
        return *this;
    }

    [[nodiscard]] constexpr move_iterator operator-(const difference_type _Off) const
        noexcept(noexcept(move_iterator(_Current - _Off)))  {
        return move_iterator(_Current - _Off);
    }

    constexpr move_iterator& operator-=(const difference_type _Off) noexcept(
        noexcept(_Current -= _Off))  {
        _Current -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const

        noexcept(noexcept(::std::ranges:: iter_move(_Current + _Off)))  {
        return ::std::ranges:: iter_move(_Current + _Off);



#line 4159 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    }


    template <sentinel_for<_Iter> _Sent>
    [[nodiscard]] friend constexpr bool
        operator==(const move_iterator& _Left, const move_sentinel<_Sent>& _Right) noexcept(
            noexcept(_Fake_copy_init<bool>(_Left._Current == _Right._Get_last())))  {
        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) noexcept(noexcept(_Left._Get_last() - _Right._Current))  {
        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) noexcept(noexcept(_Left._Current - _Right._Get_last()))  {
        return _Left._Current - _Right._Get_last();
    }

    [[nodiscard]] friend constexpr reference iter_move(const move_iterator& _It) noexcept(
        noexcept(::std::ranges:: iter_move(_It._Current))) {
        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()))) {
        ::std::ranges:: iter_swap(_Left._Current, _Right.base());
    }
#line 4192 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept {
        _Verify_range(_First._Current, _Last._Get_current());
    }

    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) noexcept {
        _Verify_range(_First._Current, _Last._Get_last());
    }
#line 4203 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 noexcept {
        _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& noexcept(
        noexcept(static_cast<move_iterator<_Unwrapped_t<const _Iter2&>>>(_Current._Unwrapped()))) {
        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() && noexcept(
        noexcept(static_cast<move_iterator<_Unwrapped_t<_Iter2>>>(::std:: move(_Current)._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) noexcept(noexcept(_Current._Seek_to(_It._Get_current()))) {
        _Current._Seek_to(_It._Get_current());
    }
    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, _Src>, int> = 0>
    constexpr void _Seek_to(move_iterator<_Src>&& _It) noexcept(
        noexcept(_Current._Seek_to(::std:: move(_It)._Get_current()))) {
        _Current._Seek_to(::std:: move(_It)._Get_current());
    }

    [[nodiscard]] constexpr const iterator_type& _Get_current() const& noexcept {
        return _Current;
    }
    [[nodiscard]] constexpr iterator_type&& _Get_current() && noexcept {
        return ::std:: move(_Current);
    }

private:
    iterator_type _Current{};
};

 template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool
    operator==(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left.base() == _Right.base()))) 

    
    requires requires {
        { _Left.base() == _Right.base() } -> _Implicitly_convertible_to<bool>;
    }

#line 4256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
{
    return _Left.base() == _Right.base();
}







#line 4267 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool
    operator<(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) noexcept(
        noexcept(_Fake_copy_init<bool>(_Left.base() < _Right.base()))) 

    
    requires requires {
        { _Left.base() < _Right.base() } -> _Implicitly_convertible_to<bool>;
    }

#line 4279 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(noexcept(_Right < _Left)) 

    requires requires { _Right < _Left; }
#line 4289 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
{
    return _Right < _Left;
}

 template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator<=(const move_iterator<_Iter1>& _Left,
    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Right < _Left)) 

    requires requires { _Right < _Left; }
#line 4299 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
{
    return !(_Right < _Left);
}

 template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator>=(const move_iterator<_Iter1>& _Left,
    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left < _Right)) 

    requires requires { _Left < _Right; }
#line 4309 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(noexcept(_Left.base() <=> _Right.base()))  {
    return _Left.base() <=> _Right.base();
}
#line 4320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr auto operator-(const move_iterator<_Iter1>& _Left,
    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left.base() - _Right.base())) 
    -> 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) noexcept(
        noexcept(move_iterator<_Iter>(_Right.base() + _Off))) 

    
    requires requires {
        { _Right.base() + _Off } -> same_as<_Iter>;
    }

#line 4339 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
{
    return move_iterator<_Iter>(_Right.base() + _Off);
}

 template <class _Iter>
[[nodiscard]] constexpr move_iterator<_Iter> make_move_iterator(_Iter _It) noexcept(
    is_nothrow_move_constructible_v<_Iter>)  {
    return move_iterator<_Iter>(::std:: move(_It));
}


template <class _Iter1, class _Iter2>
    requires (!sized_sentinel_for<_Iter1, _Iter2>)
inline constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;

 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 4367 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4392 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4415 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Iter1, class _Sent1, class _Iter2>
constexpr void _Verify_ranges_do_not_overlap(const _Iter1& _First1, const _Sent1& _Last1, const _Iter2& _First2) {

    if constexpr (_Iterators_are_contiguous<_Iter1, _Iter2>

                  && sized_sentinel_for<_Sent1, _Iter1>
#line 4483 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    ) {

        if (::std:: is_constant_evaluated()) {
            return;
        }
#line 4489 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        const auto _Offset     = _Last1 - _First1;
        const auto _Ptr1Offset = _Offset * sizeof(*_To_address(_First1));
        const auto _Ptr2Offset = _Offset * sizeof(*_To_address(_First2));
        
        
        const auto _PtrFirst1 = reinterpret_cast<const volatile char*>(_To_address(_First1));
        const auto _PtrLast1  = _PtrFirst1 + _Ptr1Offset;
        const auto _PtrFirst2 = reinterpret_cast<const volatile char*>(_To_address(_First2));
        const auto _PtrLast2  = _PtrFirst2 + _Ptr2Offset;
        do { if (_PtrLast1 <= _PtrFirst2 || _PtrLast2 <= _PtrFirst1) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 4499, 0, "%s", "ranges should not overlap each other")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"ranges should not overlap each other\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 4499, 0); } while (false); } ; } while (false);
    }




#line 4506 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
}

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 _CtgIt, class _OutCtgIt>
_OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
    const auto _Result = _Copy_memmove(_First, _First + _Count, _Dest);
    if constexpr (is_pointer_v<_OutCtgIt>) {
        return _Result;
    } else { 
        return _Dest + static_cast<_Iter_diff_t<_OutCtgIt>>(_Count);
    }
}

template <class _It, bool _RequiresMutable = false>
inline constexpr bool _Is_vb_iterator = false;

template <class _InIt, class _SizeTy, class _OutIt>
constexpr _OutIt _Copy_n_unchecked4(_InIt _First, _SizeTy _Count, _OutIt _Dest) {
    
    

    ;
#line 4545 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {

        if (!::std:: is_constant_evaluated())
#line 4550 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        {
            return _Copy_memmove_n(_First, static_cast<size_t>(_Count), _Dest);
        }
    }

    for (; _Count != 0; ++_Dest, (void) ++_First, --_Count) {
        *_Dest = *_First;
    }

    return _Dest;
}

template <class _InIt, class _Sent, class _OutIt>
using _Sent_copy_cat = conditional_t<

    is_same_v<_Sent, _InIt> || sized_sentinel_for<_Sent, _InIt>,


#line 4569 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
    _Iter_copy_cat<_InIt, _OutIt>, _False_trivial_cat>;

template <class _InIt, class _Sent, class _OutIt>
constexpr _OutIt _Copy_unchecked(_InIt _First, _Sent _Last, _OutIt _Dest) {
    
    
    if constexpr (_Sent_copy_cat<_InIt, _Sent, _OutIt>::_Bitcopy_assignable) {

        if (!::std:: is_constant_evaluated())
#line 4579 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        {

            if constexpr (is_same_v<_InIt, _Sent>)
#line 4583 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            {
                return _Copy_memmove(_First, _Last, _Dest);
            }

            else {
                return _Copy_memmove_n(_First, static_cast<size_t>(_Last - _First), _Dest);
            }
#line 4591 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        }
    }

    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, ::std:: _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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: copy(_First, _Last, _Dest);
}
#line 4621 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 <forward_iterator _It, class _Se>
        requires sentinel_for<remove_cvref_t<_Se>, _It>
    [[nodiscard]] constexpr _Unwrap_iter_t<_It, _Se> _Get_final_iterator_unwrapped(
        const _Unwrap_iter_t<_It, _Se>& _UFirst, _Se&& _Last) {
        
        
        if constexpr (is_same_v<_Unwrap_iter_t<_It, _Se>, _Unwrap_sent_t<_Se, _It>>) {
            return _Unwrap_sent<_It>(::std:: forward<_Se>(_Last));
        } else {
            return ::std::ranges:: next(_UFirst, _Unwrap_sent<_It>(::std:: forward<_Se>(_Last)));
        }
    }

    template <forward_range _Rng>
    [[nodiscard]] constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
        
        if constexpr (common_range<_Rng>) {
            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_iterator_t<_Rng>>) {
                return _Uend(_Range);
            } else {
                return _Unwrap_range_sent<_Rng>(::std::ranges:: end(_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_iterator_t<_Rng>& _Mid) {
        
        
        if constexpr (common_range<_Rng>) {
            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_iterator_t<_Rng>>) {
                return _Uend(_Range);
            } else {
                return _Unwrap_range_sent<_Rng>(::std::ranges:: end(_Range));
            }
        } else if constexpr (sized_range<_Rng>) {
            const auto _Dist = ::std::ranges:: distance(_Range);
            if constexpr (sized_sentinel_for<_Unwrapped_iterator_t<_Rng>, _Unwrapped_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 4711 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

     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 (_Sent_copy_cat<_It, _Se, _Out>::_Bitcopy_assignable) {
            if (!::std:: is_constant_evaluated()) {
                if constexpr (is_same_v<_It, _Se>) {
                    _Result = _Copy_memmove(::std:: move(_First), _Last, ::std:: move(_Result));
                    return {::std:: move(_Last), ::std:: move(_Result)};
                } else {
                    const auto _Count = static_cast<size_t>(_Last - _First);
                    _Result           = _Copy_memmove_n(_First, _Count, ::std:: move(_Result));
                    _First += _Count;
                    return {::std:: move(_First), ::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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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 4767 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4779 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            {
                _UDest = _Copy_memmove_n(_UFirst, static_cast<size_t>(_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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: copy_n(_First, _Count_raw, _Dest);
}
#line 4814 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4845 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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 4876 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, ::std:: _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_cpp17_fwd_iter_v<_FwdIt1>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: move(_First, _Last, _Dest);
}
#line 4909 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4918 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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 4957 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4971 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5026 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_cpp17_fwd_iter_v<_FwdIt>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: fill(_First, _Last, _Val);
}
#line 5053 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5068 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_cpp17_fwd_iter_v<_FwdIt>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: fill_n(_Dest, _Count_raw, _Val);
}
#line 5101 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5176 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5209 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5250 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2,
    _Pr _Pred) noexcept; 
#line 5269 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5284 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_random_iter_v<_InIt1> && _Is_ranges_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, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; 
#line 5326 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5342 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                    _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                    _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)), _Uend(_Range1),
                    _Unwrap_range_iter<_Rng2>(::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 5479 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5488 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5531 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5553 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: lexicographical_compare(_First1, _Last1, _First2, _Last2);
}
#line 5600 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5689 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _Ty, class _Elem>
struct _Vector_alg_in_find_is_safe_object_pointers : false_type {};
template <class _Ty1, class _Ty2>
struct _Vector_alg_in_find_is_safe_object_pointers<_Ty1*, _Ty2*>
    : conjunction<
          
          disjunction<is_object<_Ty1>, is_void<_Ty1>>,
          
          disjunction<is_object<_Ty2>, is_void<_Ty2>>,
          
          disjunction<is_same<remove_cv_t<_Ty1>, remove_cv_t<_Ty2>>, is_void<_Ty1>, is_void<_Ty2>>> {};


template <class _Iter, class _Ty, class _Elem = _Iter_value_t<_Iter>>
inline constexpr bool _Vector_alg_in_find_is_safe =
    
    _Iterator_is_contiguous<_Iter>
    
    && !_Iterator_is_volatile<_Iter>
    
    && disjunction_v<

        
        conjunction<is_same<_Ty, byte>, is_same<_Elem, byte>>,
#line 5715 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
       
       
        conjunction<is_integral<_Ty>, is_integral<_Elem>>,
        
        conjunction<is_pointer<_Ty>, is_same<_Ty, _Elem>>,
        
        conjunction<is_same<_Ty, nullptr_t>, is_pointer<_Elem>>,
        
        
        
        _Vector_alg_in_find_is_safe_object_pointers<_Ty, _Elem>>;

template <class _InIt, class _Ty>
[[nodiscard]] constexpr bool _Could_compare_equal_to_value_type(const _Ty& _Val) {
    
    ;

    if constexpr (disjunction_v<

                      is_same<_Ty, byte>,
#line 5736 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
                      is_same<_Ty, bool>, is_pointer<_Ty>, is_same<_Ty, nullptr_t>>) {
        return true;
    } 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>) {
            
            constexpr _Elem _Min = static_cast<_Elem>(_Elem{1} << (sizeof(_Elem) * 8 - 1));
            constexpr _Elem _Max = static_cast<_Elem>(~_Min);

            if constexpr (is_signed_v<_Ty>) {
                
                return _Min <= _Val && _Val <= _Max;
            } else {
                
                if constexpr (_Elem{-1} == static_cast<_Ty>(-1)) {
                    
                    return _Val <= _Max || static_cast<_Ty>(_Min) <= _Val;
                } else {
                    
                    return _Val <= _Max;
                }
            }
        } else {
            constexpr _Elem _Max = static_cast<_Elem>(~_Elem{0});

            if constexpr (is_unsigned_v<_Ty>) {
                
                return _Val <= _Max;
            } else {
                
                if constexpr (_Ty{-1} == static_cast<_Elem>(-1)) {
                    
                    return _Val <= _Max;
                } else {
                    
                    return 0 <= _Val && _Val <= _Max;
                }
            }
        }
    }
}

template <class _InIt, class _Ty>
[[nodiscard]] constexpr _InIt _Find_unchecked(_InIt _First, const _InIt _Last, const _Ty& _Val) {
    
    
    if constexpr (_Vector_alg_in_find_is_safe<_InIt, _Ty>) {

        if (!::std:: is_constant_evaluated())
#line 5790 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        {
            if (!::std:: _Could_compare_equal_to_value_type<_InIt>(_Val)) {
                return _Last;
            }

            const auto _First_ptr = _To_address(_First);
            const auto _Result    = __std_find_trivial(_First_ptr, _To_address(_Last), _Val);
            if constexpr (is_pointer_v<_InIt>) {
                return _Result;
            } else {
                return _First + (_Result - _First_ptr);
            }












#line 5815 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        }
    }

    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, ::std:: _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, _FwdIt _Last, const _Ty& _Val) noexcept; 
#line 5842 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Vector_alg_in_find_is_safe<_It, _Ty> && _Sized_or_unreachable_sentinel_for<_Se, _It>
                      && same_as<_Pj, identity>) {
            if (!::std:: is_constant_evaluated()) {
                if (!::std:: _Could_compare_equal_to_value_type<_It>(_Val)) {
                    if constexpr (_Is_sized) {
                        return ::std::ranges:: next(::std:: move(_First), _Last);
                    } else {
                        do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 5865, 0, "%s", "Tried to find a value in a range with unreachable sentinel" " that cannot be represented by the range's value type")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Tried to find a value in a range with unreachable sentinel\" \" that cannot be represented by the range's value type\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 5865, 0); } while (false); } ; } while (false);
#line 5866 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
                    }
                }

                using _Ptr_t = remove_reference_t<_Iter_ref_t<_It>>*;

                const auto _First_ptr = _To_address(_First);

                _Ptr_t _Result;

                if constexpr (_Is_sized) {
                    const auto _Last_ptr = _First_ptr + (_Last - _First);

                    _Result = __std_find_trivial(_First_ptr, _Last_ptr, _Val);
                } else {
                    _Result = __std_find_trivial_unsized(_First_ptr, _Val);
                }

                if constexpr (is_pointer_v<_It>) {
                    return _Result;
                } else {
                    return ::std::ranges:: next(::std:: move(_First), _Result - _First_ptr);
                }



























#line 5916 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            }
        }

        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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(
                _Unwrap_range_iter<_Rng>(::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 5961 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


        if constexpr (_Vector_alg_in_find_is_safe<decltype(_UFirst), _Ty>) {

            if (!::std:: is_constant_evaluated())
#line 5977 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            {
                if (!::std:: _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Val)) {
                    return 0;
                }

                return static_cast<_Iter_diff_t<_InIt>>(
                    __std_count_trivial(_To_address(_UFirst), _To_address(_ULast), _Val));
            }
        }
#line 5987 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        _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, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; 
#line 6005 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_bidi_iter_v<_FwdIt1> && _Is_ranges_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);

    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {

        if (!::std:: is_constant_evaluated())
#line 6186 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 6201 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    for (; _UFirst != _ULast && _UFirst != --_ULast; ++_UFirst) {
        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 6215 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _BidIt>
constexpr pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked(_BidIt _First, _BidIt _Sentinel, _BidIt _Last) {
    
    while (_First != _Sentinel && _Last != _Sentinel) {
        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_cpp17_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_cpp17_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 { 
            swap(*_UFirst, *_UNext); 
            ++_UFirst;
            ++_UNext;
            if (_UFirst == _UMid) {
                _UMid = _UNext;
            }
        } while (_UNext != _ULast);
        _Seek_wrapped(_First, _UFirst);
        while (_UMid != _ULast) { 
            _UNext = _UMid;
            do {
                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 6291 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(
                _Unwrap_range_iter<_Rng>(::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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(
                _Unwrap_range_iter<_Rng>(::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 {}};

    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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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 {}};

    
    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 = _Unwrap_iter<_Se1>(::std:: move(_First1));
            auto _ULast1  = _Unwrap_sent<_It1>(::std:: move(_Last1));
            auto _UFirst2 = _Unwrap_iter<_Se2>(::std:: move(_First2));
            auto _ULast2  = _Unwrap_sent<_It2>(::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 6618 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _Iter, class _Pr, class _Elem = _Iter_value_t<_Iter>>
inline constexpr bool _Is_min_max_optimization_safe = 
    _Iterator_is_contiguous<_Iter> 
    && !_Iterator_is_volatile<_Iter> 
    && conjunction_v<disjunction<is_integral<_Elem>, is_pointer<_Elem>>, 
        disjunction< 

            is_same<_Pr, ::std::ranges:: less>, 
#line 6628 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            is_same<_Pr, less<>>, is_same<_Pr, less<_Elem>>>>; 

template <class _FwdIt, class _Pr>
constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { 

    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
        if (!_Is_constant_evaluated()) {
            const auto _First_ptr = _To_address(_First);
            const auto _Result    = __std_max_element(_First_ptr, _To_address(_Last));
            if constexpr (is_pointer_v<_FwdIt>) {
                return _Result;
            } else {
                return _First + (_Result - _First_ptr);
            }
        }
    }
#line 6645 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    _FwdIt _Found = _First;
    if (_First != _Last) {
        while (++_First != _Last) {
            if (_Debug_lt_pred(_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, ::std:: _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) {
        ;
        ;
        ;


        if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
                      && sized_sentinel_for<_Se, _It>) {
            if (!::std:: is_constant_evaluated()) {
                const auto _First_ptr = ::std:: to_address(_First);
                const auto _Last_ptr  = _First_ptr + (_Last - _First);
                const auto _Result    = __std_max_element(_First_ptr, _Last_ptr);
                if constexpr (is_pointer_v<_It>) {
                    return _Result;
                } else {
                    return _First + (_Result - _First_ptr);
                }
            }
        }
#line 6708 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        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(_Unwrap_iter<_Se>(::std:: move(_First)),
                                      _Unwrap_sent<_It>(::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 _UResult =
                ::std::ranges:: _Max_element_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }
    };

     inline constexpr _Max_element_fn max_element{_Not_quite_object::_Construct_tag {}};
} 
#line 6748 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
#line 6749 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Ty, class _Pr>
[[nodiscard]] constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
    
    const _Ty* _Res = ::std:: _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();
            do { if (_First != _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6792, 0, "%s", "An initializer_list passed to std::ranges::max must not be empty. (N4950 [alg.min.max]/13)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"An initializer_list passed to std::ranges::max must not be empty. (N4950 [alg.min.max]/13)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6792, 0); } while (false); } ; } while (false);
#line 6793 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            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);
            do { if (_UFirst != _ULast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6803, 0, "%s", "A range passed to std::ranges::max must not be empty. (N4950 [alg.min.max]/13)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"A range passed to std::ranges::max must not be empty. (N4950 [alg.min.max]/13)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6803, 0); } while (false); } ; } while (false);
#line 6804 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            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 6823 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

template <class _FwdIt, class _Pr>
constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { 

    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
        if (!_Is_constant_evaluated()) {
            const auto _First_ptr = _To_address(_First);
            const auto _Result    = __std_min_element(_First_ptr, _To_address(_Last));
            if constexpr (is_pointer_v<_FwdIt>) {
                return _Result;
            } else {
                return _First + (_Result - _First_ptr);
            }
        }
    }
#line 6839 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    _FwdIt _Found = _First;
    if (_First != _Last) {
        while (++_First != _Last) {
            if (_Debug_lt_pred(_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, ::std:: _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) {
        ;
        ;
        ;


        if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
                      && sized_sentinel_for<_Se, _It>) {
            if (!::std:: is_constant_evaluated()) {
                const auto _First_ptr = ::std:: to_address(_First);
                const auto _Last_ptr  = _First_ptr + (_Last - _First);
                const auto _Result    = __std_min_element(_First_ptr, _Last_ptr);
                if constexpr (is_pointer_v<_It>) {
                    return _Result;
                } else {
                    return _First + (_Result - _First_ptr);
                }
            }
        }
#line 6902 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

        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(_Unwrap_iter<_Se>(::std:: move(_First)),
                                      _Unwrap_sent<_It>(::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 _UResult =
                ::std::ranges:: _Min_element_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }
    };

     inline constexpr _Min_element_fn min_element{_Not_quite_object::_Construct_tag {}};
} 
#line 6942 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
#line 6943 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

 template <class _Ty, class _Pr>
[[nodiscard]] constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
    
    const _Ty* _Res = ::std:: _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();
            do { if (_First != _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6980, 0, "%s", "An initializer_list passed to std::ranges::min must not be empty. (N4950 [alg.min.max]/5)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"An initializer_list passed to std::ranges::min must not be empty. (N4950 [alg.min.max]/5)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6980, 0); } while (false); } ; } while (false);
#line 6981 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            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);
            do { if (_UFirst != _ULast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6991, 0, "%s", "A range passed to std::ranges::min must not be empty. (N4950 [alg.min.max]/5)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"A range passed to std::ranges::min must not be empty. (N4950 [alg.min.max]/5)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility", 6991, 0); } while (false); } ; } while (false);
#line 6992 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
            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 7011 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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<>{});
}

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 7080 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
        {
            __std_swap_ranges_trivially_swappable_noalias(
                _To_address(_First1), _To_address(_Last1), _To_address(_First2));
            return _First2 + (_Last1 - _First1);
        }
    }
#line 7087 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

    for (; _First1 != _Last1; ++_First1, (void) ++_First2) {
        swap(*_First1, *_First2); 
    }

    return _First2;
}

extern "C++" [[noreturn]]  void __cdecl _Xbad_alloc();
extern "C++" [[noreturn]]  void __cdecl _Xinvalid_argument(  const char*);
extern "C++" [[noreturn]]  void __cdecl _Xlength_error(  const char*);
extern "C++" [[noreturn]]  void __cdecl _Xout_of_range(  const char*);
extern "C++" [[noreturn]]  void __cdecl _Xoverflow_error(  const char*);
extern "C++" [[noreturn]]  void __cdecl _Xruntime_error(  const char*);
extern "C++" [[noreturn]]  void __cdecl _XGetLastError();

 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 suppress 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 7166 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"







































































#line 7238 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"

}






#pragma warning(pop)
#pragma pack(pop)
#line 7249 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
#line 7250 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xutility"
#pragma external_header(pop)
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"





#pragma once






#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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...>;

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>...>; 





#line 73 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

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>...>; 





#line 93 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

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 _OtherTuple, class... _Other>
struct _Tuple_convert_val : true_type {};

template <class _This, class _OtherTuple, class _Uty>
struct _Tuple_convert_val<tuple<_This>, _OtherTuple, _Uty>
    : bool_constant<!disjunction_v<is_same<_This, _Uty>, is_constructible<_This, _OtherTuple>,
          is_convertible<_OtherTuple, _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_cvref_t<_This2>>> {};

template <class _Ty0, class _Ty1, class _Uty0, class _Uty1>
struct _Tuple_perfect_val<tuple<_Ty0, _Ty1>, _Uty0, _Uty1>
    : bool_constant<disjunction_v<negation<is_same<_Remove_cvref_t<_Uty0>, allocator_arg_t>>,
          is_same<_Remove_cvref_t<_Ty0>, allocator_arg_t>>> {};

template <class _Ty0, class _Ty1, class _Ty2, class _Uty0, class _Uty1, class _Uty2>
struct _Tuple_perfect_val<tuple<_Ty0, _Ty1, _Ty2>, _Uty0, _Uty1, _Uty2>
    : bool_constant<disjunction_v<negation<is_same<_Remove_cvref_t<_Uty0>, allocator_arg_t>>,
          is_same<_Remove_cvref_t<_Ty0>, allocator_arg_t>>> {};

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;
}; 







































#line 221 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

template <>
class tuple<> { 
public:
    constexpr tuple() noexcept = default; 

    constexpr tuple(const tuple&) noexcept  {} 





#line 234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    template <class _Alloc>
    constexpr tuple(allocator_arg_t, const _Alloc&) noexcept  {}

    template <class _Alloc>
    constexpr tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept  {}





#line 246 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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;


















#line 273 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    constexpr void swap(tuple&) noexcept {}


#line 278 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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 292 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"













#line 306 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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() {}

    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...) {}

    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)...) {}

    tuple(const tuple&) = default;
    tuple(tuple&&)      = default;








#line 375 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    template <class... _Other, enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, const _Other&...>,
                                               ::std:: _Tuple_convert_val<tuple, const tuple<_Other...>&, _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) {}

    template <class... _Other, enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, _Other...>,
                                               ::std:: _Tuple_convert_val<tuple, tuple<_Other...>, _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 406 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {}

    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 450 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {}

    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...) {}

    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)...) {}

    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)) {}









#line 491 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    template <class _Alloc, class... _Other,
        enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, const _Other&...>,
                        ::std:: _Tuple_convert_val<tuple, const tuple<_Other...>&, _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) {}

    template <class _Alloc, class... _Other,
        enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, _Other...>,
                        ::std:: _Tuple_convert_val<tuple, tuple<_Other...>, _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 523 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {}

    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 559 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }













#line 586 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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;
    }













#line 611 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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;
    }











#line 633 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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;
    }











#line 655 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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;
    }










#line 675 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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;
    }




















































#line 736 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    constexpr void swap(tuple& _Right) noexcept(
        conjunction_v<_Is_nothrow_swappable<_This>, _Is_nothrow_swappable<_Rest>...>) {
        using ::std:: swap;
        swap(_Myfirst._Val, _Right._Myfirst._Val); 
        _Mybase::swap(_Right._Get_rest());
    }









#line 753 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

    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 817 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"






#line 824 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 871 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (N4950 [tuple.rel]/2).");
    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) {
    return _Left._Three_way_compare(_Right);
}




























#line 914 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

 template <class... _Types, enable_if_t<conjunction_v<_Is_swappable<_Types>...>, int> = 0>
constexpr void swap(tuple<_Types...>& _Left, tuple<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}







#line 927 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

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 _Ty, class _Kx_arg, class _Ix_arg, size_t _Ix_next, class... _Sequences>
struct _Tuple_cat2;

template <class _Ty, size_t... _Kx, size_t... _Ix, size_t _Ix_next>
struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next> {
    using _Ret    = tuple<tuple_element_t<_Kx, _Remove_cvref_t<tuple_element_t<_Ix, _Ty>>>...>;
    using _Kx_seq = index_sequence<_Kx...>;
    using _Ix_seq = index_sequence<_Ix...>;
};

template <class _Ty, size_t... _Kx, size_t... _Ix, size_t _Ix_next, size_t... _Kx_next, class... _Rest>
struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next, index_sequence<_Kx_next...>, _Rest...>
    : _Tuple_cat2<_Ty, index_sequence<_Kx..., _Kx_next...>,
          index_sequence<_Ix..., (_Ix_next + 0 * _Kx_next)...>, 
          _Ix_next + 1, _Rest...> {};



#line 1047 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
template <class... _Tuples>
#line 1049 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
using _Tuple_cat1 = _Tuple_cat2<tuple<_Tuples&&...>, index_sequence<>, index_sequence<>, 0,
    make_index_sequence<tuple_size_v<_Remove_cvref_t<_Tuples>>>...>;

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:: move(_Arg)))...};
}



#line 1060 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
 template <class... _Tuples>
#line 1062 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
[[nodiscard]] constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&... _Tpls) { 
    using _Cat1   = _Tuple_cat1<_Tuples...>;
    using _Ret    = typename _Cat1::_Ret;
    using _Kx_seq = typename _Cat1::_Kx_seq;
    using _Ix_seq = typename _Cat1::_Ix_seq;
    return _Tuple_cat<_Ret>(_Kx_seq{}, _Ix_seq{}, ::std:: forward_as_tuple(::std:: forward<_Tuples>(_Tpls)...));
}




#line 1074 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
template <class _Callable, class _Tuple, size_t... _Indices>
#line 1076 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
constexpr decltype(auto) _Apply_impl(_Callable&& _Obj, _Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
    noexcept(::std:: invoke(::std:: forward<_Callable>(_Obj), ::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl))...))) {
    return ::std:: invoke(::std:: forward<_Callable>(_Obj), ::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl))...);
}



#line 1084 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
 template <class _Callable, class _Tuple>
#line 1086 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
    noexcept(_Apply_impl(::std:: forward<_Callable>(_Obj), ::std:: forward<_Tuple>(_Tpl),
        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
    return _Apply_impl(::std:: forward<_Callable>(_Obj), ::std:: forward<_Tuple>(_Tpl),
        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
}



#line 1096 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
template <class _Ty, class _Tuple, size_t... _Indices>
#line 1098 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
    is_nothrow_constructible_v<_Ty, decltype(::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl)))...>) {
    
    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 (N4950 [tuple.apply]/4).");
    return _Ty(::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl))...);
}



#line 1109 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
 template <class _Ty, class _Tuple>
#line 1111 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
[[nodiscard]] constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_Make_from_tuple_impl<_Ty>(
    ::std:: forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{})))  {
    
    return _Make_from_tuple_impl<_Ty>(
        ::std:: forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
}
#line 1118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

template <class... _Types, class _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type {}; 















































#line 1169 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"










#line 1180 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"

}



#pragma warning(pop)
#pragma pack(pop)
#line 1188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
#line 1189 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tuple"
#pragma external_header(pop)
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Ptrty>
[[nodiscard]] constexpr auto _Unfancy(_Ptrty _Ptr) noexcept { 
    return ::std:: addressof(*_Ptr);
}

template <class _Ty>
[[nodiscard]] constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { 
    return _Ptr;
}

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), 16ull);

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 108 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
};

constexpr bool _Is_pow_2(const size_t _Value) noexcept {
    return _Value != 0 && (_Value & (_Value - 1)) == 0;
}


inline constexpr size_t _Big_allocation_threshold = 4096;
inline constexpr size_t _Big_allocation_alignment = 32;


;


;


inline constexpr size_t _Non_user_size = 2 * sizeof(void*) + _Big_allocation_alignment - 1;


#line 129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"


inline constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAFAFAFAFAULL;


#line 135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 145, 0, "%s", "invalid argument")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid argument\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 145, 0); } 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;


    static_cast<uintptr_t*>(_Ptr)[-2] = _Big_allocation_sentinel;
#line 152 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    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];

    
    
    do { if (_Ptr_user[-2] == _Big_allocation_sentinel) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 164, 0, "%s", "invalid argument")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid argument\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 164, 0); } while (false); } ; } while (false);

    
    

    constexpr uintptr_t _Min_back_shift = 2 * sizeof(void*);


#line 173 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 174, 0, "%s", "invalid argument")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid argument\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 174, 0); } while (false); } ; } while (false);
    _Ptr = reinterpret_cast<void*>(_Ptr_container);
}
#line 178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"


template <size_t _Align, class _Traits = _Default_allocate_traits,
    enable_if_t<(_Align > 16ull), 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 193 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        size_t _Passed_align = _Align;

        if (_Bytes >= _Big_allocation_threshold) {
            
            _Passed_align = (::std:: max)(_Align, _Big_allocation_alignment);
        }
#line 201 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        return _Traits::_Allocate_aligned(_Bytes, _Passed_align);
    }
}

template <size_t _Align, enable_if_t<(_Align > 16ull), int> = 0>
constexpr void _Deallocate(void* _Ptr, const size_t _Bytes) noexcept {
    

    if (::std:: is_constant_evaluated()) {
        ::operator delete(_Ptr);
    } else
#line 213 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        size_t _Passed_align = _Align;

        if (_Bytes >= _Big_allocation_threshold) { 
            _Passed_align = (::std:: max)(_Align, _Big_allocation_alignment);
        }
#line 220 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        ::operator delete(_Ptr, _Bytes, align_val_t{_Passed_align});
    }
}




#line 228 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

template <size_t _Align, class _Traits = _Default_allocate_traits,
    enable_if_t<(!1 || _Align <= 16ull), int> = 0>
__declspec(allocator) constexpr void* _Allocate(const size_t _Bytes) {
    


    if (!::std:: is_constant_evaluated())
#line 237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        if (_Bytes >= _Big_allocation_threshold) { 
            return _Allocate_manually_vector_aligned<_Traits>(_Bytes);
        }
    }
#line 243 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

    if (_Bytes != 0) {
        return _Traits::_Allocate(_Bytes);
    }

    return nullptr;
}

template <size_t _Align, enable_if_t<(!1 || _Align <= 16ull), int> = 0>
constexpr void _Deallocate(void* _Ptr, size_t _Bytes) noexcept {
    

    if (::std:: is_constant_evaluated()) {
        ::operator delete(_Ptr);
    } else
#line 259 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {

        if (_Bytes >= _Big_allocation_threshold) { 
            _Adjust_manually_vector_aligned(_Ptr, _Bytes);
        }
#line 265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        _Location->~_Ty();
    }
}
#line 325 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {};








#line 481 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

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 _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 {};







#line 540 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

 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("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al, __declspec(guard(overflow)) const size_type _Count) {
        return _Al.allocate(_Count);
    }

    [[nodiscard("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al, __declspec(guard(overflow)) 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);
        }
    }










#line 593 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

    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 606 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 619 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al, __declspec(guard(overflow)) const size_type _Count) {

        if (::std:: is_constant_evaluated()) {
            return _Al.allocate(_Count);
        } else
#line 673 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            (void) _Al;
            return static_cast<pointer>(
                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
        }
    }

    [[nodiscard("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al, __declspec(guard(overflow)) const size_type _Count, const_void_pointer) {

        if (::std:: is_constant_evaluated()) {
            return _Al.allocate(_Count);
        } else
#line 687 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            (void) _Al;
            return static_cast<pointer>(
                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
        }
    }






#line 700 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

    static constexpr void deallocate(_Alloc& _Al, const pointer _Ptr, const size_type _Count) {
        

        if (::std:: is_constant_evaluated()) {
            _Al.deallocate(_Ptr, _Count);
        } else
#line 708 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {

        ::std:: construct_at(_Ptr, ::std:: forward<_Types>(_Args)...);


#line 721 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    }

    template <class _Uty>
    static constexpr void destroy(_Alloc&, _Uty* const _Ptr) {

        ::std:: destroy_at(_Ptr);


#line 730 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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*;
};


inline constexpr size_t _Asan_granularity      = 8;
inline constexpr size_t _Asan_granularity_mask = _Asan_granularity - 1;

struct _Asan_aligned_pointers {
    const void* _First;
    const void* _End;

    [[nodiscard]] constexpr const void* _Clamp_to_end(const void* _Mid) const noexcept {
        ;
        if (_Mid > _End) {
            return _End;
        } else {
            return _Mid;
        }
    }
};

















































































[[nodiscard]] inline _Asan_aligned_pointers _Get_asan_aligned_first_end(
    const void* const _First, const void* const _End) noexcept {
    return {
        reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(_First) & ~_Asan_granularity_mask),
        reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(_End) & ~_Asan_granularity_mask),
    };
}




[[nodiscard]] inline const void* _Get_asan_aligned_after(const void* const _End) noexcept {
    return reinterpret_cast<const void*>(
        (reinterpret_cast<uintptr_t>(_End) + _Asan_granularity_mask) & ~_Asan_granularity_mask);
}

template <class _Container, class = void>
inline constexpr size_t _Container_allocation_minimum_asan_alignment = alignof(typename _Container::value_type);

template <class _Container>
inline constexpr size_t _Container_allocation_minimum_asan_alignment<_Container,
    void_t<decltype(_Container::allocator_type::_Minimum_asan_allocation_alignment)>> =
    (::std:: max)(
        alignof(typename _Container::value_type), _Container::allocator_type::_Minimum_asan_allocation_alignment);

 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.");
    static_assert(!is_function_v<_Ty>, "The C++ Standard forbids allocators for function elements "
                                       "because of [allocator.requirements].");
    static_assert(!is_reference_v<_Ty>, "The C++ Standard forbids allocators for reference elements "
                                        "because of [allocator.requirements].");

    using _From_primary = allocator;

    using value_type = _Ty;







#line 936 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress this warning.")]] = true_type;














#line 957 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        do { if (_Ptr != nullptr || _Count == 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 967, 0, "%s", "null pointer cannot point to a block of non-zero size")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"null pointer cannot point to a block of non-zero size\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 967, 0); } while (false); } ; } while (false);
        
        _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
    }

    [[nodiscard("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] constexpr __declspec(allocator) _Ty* allocate(__declspec(guard(overflow)) const size_t _Count) {
        static_assert(sizeof(value_type) > 0, "value_type must be complete before calling allocate.");
        return static_cast<_Ty*>(_Allocate<_New_alignof<_Ty>>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
    }






#line 983 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"




















#line 1004 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

    static constexpr size_t _Minimum_asan_allocation_alignment = _Asan_granularity;
};
























#line 1032 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

 template <class _Ty, class _Other>
[[nodiscard]] constexpr bool operator==(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
    return true;
}






#line 1044 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"



template <class _Alloc>
using _Guide_size_type_t =
    typename allocator_traits<conditional_t<_Is_allocator<_Alloc>::value, _Alloc, allocator<int>>>::size_type;
#line 1051 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Left, _Right); 
    } else {
        do { if (_Left == _Right) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 1077, 0, "%s", "containers incompatible for swap")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"containers incompatible for swap\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 1077, 0); } while (false); } ; } while (false);
    }
}

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, class _Unsigned_type>
[[nodiscard]] constexpr _Size_type _Convert_size(const _Unsigned_type _Len) noexcept(
    sizeof(_Unsigned_type) <= sizeof(_Size_type)) {
    
    ;
    ;

    if constexpr (sizeof(_Unsigned_type) > sizeof(_Size_type)) {
        if (_Len > (numeric_limits<_Size_type>::max)()) {
            _Xlength_error("size is 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 {


        if (::std:: is_constant_evaluated()) {
            _Assign_unlocked(_Right);
        } else
#line 1251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            _Assign_locked(_Right);
        }


#line 1257 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        return *this;
    }


    constexpr ~_Iterator_base12() noexcept {

        if (::std:: is_constant_evaluated()) {
            _Orphan_me_unlocked_v3();
        } else
#line 1267 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            _Orphan_me_locked_v3();
        }
    }

    constexpr void _Adopt(const _Container_base12* _Parent) noexcept {

        if (::std:: is_constant_evaluated()) {
            _Adopt_unlocked(_Parent);
        } else
#line 1278 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            _Adopt_locked(_Parent);
        }
    }








#line 1291 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

    constexpr const _Container_base12* _Getcont() const noexcept {
        return _Myproxy ? _Myproxy->_Mycont : nullptr;
    }

    static constexpr bool _Unwrap_when_unverified = 2 == 0;

    mutable _Container_proxy* _Myproxy    = nullptr;
    mutable _Iterator_base12* _Mynextiter = nullptr;


private:
    constexpr void _Assign_unlocked(const _Iterator_base12& _Right) noexcept {
        if (_Myproxy == _Right._Myproxy) {
            return;
        }

        if (_Right._Myproxy) {
            _Adopt_unlocked(_Right._Myproxy->_Mycont);
        } else { 
            _Orphan_me_unlocked_v3();
        }
    }

    void _Assign_locked(const _Iterator_base12& _Right) noexcept {
        _Lockit _Lock(3);
        _Assign_unlocked(_Right);
    }

    constexpr void _Adopt_unlocked(const _Container_base12* _Parent) noexcept {
        if (!_Parent) {
            _Orphan_me_unlocked_v3();
            return;
        }

        _Container_proxy* _Parent_proxy = _Parent->_Myproxy;
        if (_Myproxy != _Parent_proxy) { 
            if (_Myproxy) { 
                _Orphan_me_unlocked_v3();
            }
            _Mynextiter                 = _Parent_proxy->_Myfirstiter;
            _Parent_proxy->_Myfirstiter = this;
            _Myproxy                    = _Parent_proxy;
        }
    }

    void _Adopt_locked(const _Container_base12* _Parent) noexcept {
        _Lockit _Lock(3);
        _Adopt_unlocked(_Parent);
    }

    constexpr void _Orphan_me_unlocked_v3() noexcept {
        if (!_Myproxy) { 
            return;
        }

        
        _Iterator_base12** _Pnext = &_Myproxy->_Myfirstiter;
        while (*_Pnext && *_Pnext != this) {
            _Pnext = &(*_Pnext)->_Mynextiter;
        }

        do { if (*_Pnext) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 1353, 0, "%s", "ITERATOR LIST CORRUPTED!")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"ITERATOR LIST CORRUPTED!\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 1353, 0); } while (false); } ; } while (false);
        *_Pnext  = _Mynextiter;
        _Myproxy = nullptr;
    }

    void _Orphan_me_locked_v3() noexcept {
        _Lockit _Lock(3);
        _Orphan_me_unlocked_v3();
    }
#line 1363 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
};

constexpr void _Container_base12::_Orphan_all_unlocked_v3() noexcept {
    if (!_Myproxy) { 
        return;
    }

    
    for (auto _Pnext = ::std:: exchange(_Myproxy->_Myfirstiter, nullptr); _Pnext; _Pnext = _Pnext->_Mynextiter) {
        _Pnext->_Myproxy = nullptr;
    }
}

constexpr void _Container_base12::_Orphan_all() noexcept {


    if (::std:: is_constant_evaluated()) {
        _Orphan_all_unlocked_v3();
    } else
#line 1383 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        _Orphan_all_locked_v3();
    }
#line 1387 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {


    if (::std:: is_constant_evaluated()) {
        _Swap_proxy_and_iterators_unlocked(_Right);
    } else
#line 1410 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        _Swap_proxy_and_iterators_locked(_Right);
    }


#line 1416 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
}




#line 1422 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
using _Container_base = _Container_base12;
using _Iterator_base  = _Iterator_base12;
#line 1425 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
        }
    }
};






#line 1492 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

template <class _Alloc>
using _Container_proxy_ptr = _Container_proxy_ptr12<_Rebind_alloc_t<_Alloc, _Container_proxy>>;
#line 1496 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) > 16ull) {
                _Pbuf = ::operator new(_Size, align_val_t{alignof(_Ty)}, nothrow);
            } else
#line 1571 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) > 16ull) {
        ::operator delete(_Pbuf, align_val_t{alignof(_Ty)});
    } else
#line 1591 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1633 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>>, remove_reference_t<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 += static_cast<iter_difference_t<_InIt>>(_Count);
        }

        if constexpr (is_pointer_v<_OutIt>) {
            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
        } else {
            _OFirst += static_cast<iter_difference_t<_OutIt>>(_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 += static_cast<iter_difference_t<_InIt>>(_Count_bytes / sizeof(iter_value_t<_InIt>));
        }

        if constexpr (is_pointer_v<_OutIt>) {
            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
        } else {
            _OFirst += static_cast<iter_difference_t<_OutIt>>(_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 {
                do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 1764, 0, "%s", "Tried to uninitialized_move two ranges with unreachable sentinels")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Tried to uninitialized_move two ranges with unreachable sentinels\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory", 1764, 0); } while (false); } ; } while (false);
            }
        } 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 1778 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

template <class _Alloc>
class [[nodiscard]] _Uninitialized_backout_al {
    
private:
    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 _Se, class _Alloc>
constexpr _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
    _InIt _First, _Se _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
    
    
    using _Ptrval = typename _Alloc::value_type*;


    auto _UFirst = ::std::ranges:: _Unwrap_iter<_Se>(::std:: move(_First));
    auto _ULast  = ::std::ranges:: _Unwrap_sent<_InIt>(::std:: move(_Last));





#line 1828 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

    constexpr bool _Can_memmove = _Sent_copy_cat<decltype(_UFirst), decltype(_ULast), _Ptrval>::_Bitcopy_constructible
                               && _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>::value;

    if constexpr (_Can_memmove) {

        if (!::std:: is_constant_evaluated())
#line 1836 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            if constexpr (is_same_v<decltype(_UFirst), decltype(_ULast)>) {
                _Copy_memmove(_To_address(_UFirst), _To_address(_ULast), _Unfancy(_Dest));
                _Dest += _ULast - _UFirst;
            } else {
                const auto _Count = static_cast<size_t>(_ULast - _UFirst);
                _Copy_memmove_n(_To_address(_UFirst), _Count, _Unfancy(_Dest));
                _Dest += _Count;
            }
            return _Dest;
        }
    }

    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
    for (; _UFirst != _ULast; ++_UFirst) {
        _Backout._Emplace_back(*_UFirst);
    }

    return _Backout._Release();
}

template <class _InIt, class _Alloc>
constexpr _Alloc_ptr_t<_Alloc> _Uninitialized_copy_n(
    _InIt _First, size_t _Count, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
    
    
    using _Ptrval = typename _Alloc::value_type*;

    auto _UFirst = _Get_unwrapped(::std:: move(_First));

    constexpr bool _Can_memmove =
        conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
            _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>;

    if constexpr (_Can_memmove) {

        if (!::std:: is_constant_evaluated())
#line 1874 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
        {
            _Copy_memmove_n(_UFirst, _Count, _Unfancy(_Dest));
            _Dest += _Count;
            return _Dest;
        }
    }

    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
    for (; _Count != 0; ++_UFirst, (void) --_Count) {
        _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 1896 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1933 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1956 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1964 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2028 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2070 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2152 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }
}














#line 2191 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

template <class _Alloc>
[[nodiscard("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] constexpr typename allocator_traits<_Alloc>::pointer _Allocate_at_least_helper(
    _Alloc& _Al, __declspec(guard(overflow)) typename allocator_traits<_Alloc>::size_type& _Count) {






#line 2202 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        return _Al.allocate(_Count);
    }
}

 template <class _FwdIt, class _Ty>
[[nodiscard("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] 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           = ::std:: _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("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] 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 _Ty1, class _Ty2>
void _Deduce_as_pair(const pair<_Ty1, _Ty2>&); 

template <class _Ty, class = void>
inline constexpr bool _Is_deducible_as_pair = false;

template <class _Ty>
inline constexpr bool _Is_deducible_as_pair<_Ty, decltype(::std:: _Deduce_as_pair(::std:: declval<_Ty>()))> = true;

template <class _Ty>
inline constexpr bool _Is_cv_pair = _Is_specialization_v<remove_cv_t<_Ty>, pair>;

template <class _Ty>
const _Ty& _Normally_bind(_Identity_t<const _Ty&>); 

template <class _Ty>
_Ty&& _Normally_bind(_Identity_t<_Ty&&>); 

template <class _Ty, class _Uty>
using _Normally_bound_ref = decltype(::std:: _Normally_bind<_Ty>(::std:: declval<_Uty>()));

template <class _Ty, class _Uty, class = void>
inline constexpr bool _Is_normally_bindable = false;

template <class _Ty, class _Uty>
inline constexpr bool _Is_normally_bindable<_Ty, _Uty, void_t<_Normally_bound_ref<_Ty, _Uty>>> = true;


 template <class _Ty, class _Alloc, class... _Types, enable_if_t<!_Is_cv_pair<_Ty>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Types&&... _Args) noexcept {
    if constexpr (!uses_allocator_v<remove_cv_t<_Ty>, _Alloc>) {
        static_assert(is_constructible_v<_Ty, _Types...>,
            "If uses_allocator_v<remove_cv_t<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<remove_cv_t<T>, Alloc> is true");
    }
}

 template <class _Ty, class _Alloc, enable_if_t<_Is_cv_pair<_Ty>, 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_cv_pair<_Ty>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept;




#line 2344 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

 template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_cv_pair<_Ty>, 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_cv_pair<_Ty>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept;





#line 2356 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"




#line 2361 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
 template <class _Ty, class _Alloc, class _Uty,
    enable_if_t<_Is_cv_pair<_Ty> && !_Is_deducible_as_pair<_Uty&>, int> = 0>
#line 2364 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept;

 template <class _Ty, class _Alloc, class _Tuple1, class _Tuple2, enable_if_t<_Is_cv_pair<_Ty>, 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_cv_pair<_Ty>, 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_cv_pair<_Ty>, 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)));
}











#line 2413 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

 template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_cv_pair<_Ty>, 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_cv_pair<_Ty>, 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))));
}












#line 2447 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"




#line 2452 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
 template <class _Ty, class _Alloc, class _Uty,
    enable_if_t<_Is_cv_pair<_Ty> && !_Is_deducible_as_pair<_Uty&>, int> >
#line 2455 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept {











#line 2468 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
    {
        struct _Pair_remaker {
            const _Alloc& _Al;
            _Uty& _Ux;

            constexpr operator remove_cv_t<_Ty>() const {
                using _Pair_t = remove_cv_t<_Ty>;
                static_assert(_Is_normally_bindable<_Pair_t, _Uty>,
                    "The argument must be bindable to a reference to the std::pair type.");

                using _Pair_first_t   = typename _Pair_t::first_type;
                using _Pair_second_t  = typename _Pair_t::second_type;
                using _Pair_ref_t     = _Normally_bound_ref<_Pair_t, _Uty>;
                _Pair_ref_t _Pair_ref = ::std:: forward<_Uty>(_Ux);
                if constexpr (is_same_v<_Pair_ref_t, const _Pair_t&>) {
                    
                    
                    return _Pair_t{piecewise_construct,
                        ::std:: uses_allocator_construction_args<_Pair_first_t>(_Al, _Pair_ref.first),
                        ::std:: uses_allocator_construction_args<_Pair_second_t>(_Al, _Pair_ref.second)};
                } else {
                    
                    
                    return _Pair_t{piecewise_construct,
                        ::std:: uses_allocator_construction_args<_Pair_first_t>(_Al, ::std:: get<0>(::std:: move(_Pair_ref))),
                        ::std:: uses_allocator_construction_args<_Pair_second_t>(_Al, ::std:: get<1>(::std:: move(_Pair_ref)))};
                }
            }
        };

        
        
        return tuple<_Pair_remaker>({_Al, _Ux});
    }
}

 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 2518 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"




















#line 2539 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"

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;
    }
};

 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 <class _Ty, class = void>
inline constexpr bool _Is_transparent_v = false;

template <class _Ty>
inline constexpr bool _Is_transparent_v<_Ty, void_t<typename _Ty::is_transparent>> = true;

template <class _Ty>
struct _Is_transparent : bool_constant<_Is_transparent_v<_Ty>> {};


template <class _Ty>
concept _Transparent = _Is_transparent_v<_Ty>;
#line 2609 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
}



#pragma warning(pop)
#pragma pack(pop)
#line 2616 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#line 2617 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmemory"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"



#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

#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 _Min_max_element_t {
    const void* _Min;
    const void* _Max;
};








__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;

_Min_max_element_t __stdcall __std_minmax_element_1(const void* _First, const void* _Last, bool _Signed) noexcept;
_Min_max_element_t __stdcall __std_minmax_element_2(const void* _First, const void* _Last, bool _Signed) noexcept;
_Min_max_element_t __stdcall __std_minmax_element_4(const void* _First, const void* _Last, bool _Signed) noexcept;
_Min_max_element_t __stdcall __std_minmax_element_8(const void* _First, const void* _Last, bool _Signed) noexcept;
}

template <class _Ty>
::std:: pair<_Ty*, _Ty*> __std_minmax_element(_Ty* _First, _Ty* _Last) noexcept {
    constexpr bool _Signed = ::std:: is_signed_v<_Ty>;

    _Min_max_element_t _Res;

    if constexpr (sizeof(_Ty) == 1) {
        _Res = __std_minmax_element_1(_First, _Last, _Signed);
    } else if constexpr (sizeof(_Ty) == 2) {
        _Res = __std_minmax_element_2(_First, _Last, _Signed);
    } else if constexpr (sizeof(_Ty) == 4) {
        _Res = __std_minmax_element_4(_First, _Last, _Signed);
    } else if constexpr (sizeof(_Ty) == 8) {
        _Res = __std_minmax_element_8(_First, _Last, _Signed);
    } else {
        static_assert(::std:: _Always_false<_Ty>, "Unexpected size");
    }

    return {const_cast<_Ty*>(static_cast<const _Ty*>(_Res._Min)), const_cast<_Ty*>(static_cast<const _Ty*>(_Res._Max))};
}
#line 81 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>(9223372036854775807i64), 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_storage_t<sizeof(_Ty), alignof(_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};
        }
    };



















#line 243 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
} 
#line 245 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 283 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(
                _Unwrap_range_iter<_Rng>(::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 364 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"


 template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 369 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 390 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 425 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"


namespace ranges {
    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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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) {
            ;
            ;
            ;


            if constexpr (is_same_v<_Pj, identity> && _Vector_alg_in_find_is_safe<_It, _Ty>
                          && sized_sentinel_for<_Se, _It>) {
                if (!::std:: is_constant_evaluated()) {
                    if (!::std:: _Could_compare_equal_to_value_type<_It>(_Val)) {
                        return 0;
                    }

                    const auto _First_ptr = _To_address(_First);
                    const auto _Last_ptr  = _First_ptr + (_Last - _First);

                    return static_cast<iter_difference_t<_It>>(__std_count_trivial(_First_ptr, _Last_ptr, _Val));
                }
            }
#line 470 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

            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 485 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 506 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 549 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 572 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: mismatch(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, equal_to{});
}
#line 589 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_random_iter_v<_InIt1> && _Is_ranges_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 627 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_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 644 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"


namespace ranges {
    template <input_iterator _It1, input_iterator _It2, _Integer_like _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 = _Unwrap_iter<_Se1>(::std:: move(_First1));
            auto _ULast1  = _Unwrap_sent<_It1>(::std:: move(_Last1));
            auto _UFirst2 = _Unwrap_iter<_Se2>(::std:: move(_First2));
            auto _ULast2  = _Unwrap_sent<_It2>(::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 ::std::ranges:: _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 ::std::ranges:: _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 745 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
[[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);
    auto _UFirst1 = _Get_unwrapped(_First1);
    auto _ULast1  = _Get_unwrapped(_Last1);
    auto _UFirst2 = _Get_unwrapped(_First2);
    auto _ULast2  = _Get_unwrapped(_Last2);
    if constexpr (_Is_ranges_random_iter_v<_FwdIt1> && _Is_ranges_random_iter_v<_FwdIt2>) {
        if (_ULast1 - _UFirst1 != _ULast2 - _UFirst2) {
            return false;
        }

        for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) { 
            if (!_Pred(*_UFirst1, *_UFirst2)) {
                
                return _Check_match_counts(_UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred));
            }
        }

        return true;
    } else {
        static_assert(_Is_ranges_fwd_iter_v<_FwdIt1> && _Is_ranges_fwd_iter_v<_FwdIt2>,
            "Iterators must be at least forward iterators");
        for (;; ++_UFirst1, (void) ++_UFirst2) { 
            if (_UFirst1 == _ULast1) {
                return _UFirst2 == _ULast2;
            }

            if (_UFirst2 == _ULast2) {
                return false;
            }

            if (!_Pred(*_UFirst1, *_UFirst2)) { 
                break;
            }
        }

        auto _Next1 = _UFirst1;
        auto _Next2 = _UFirst2;
        for (;; ++_Next1, (void) ++_Next2) { 
            if (_Next1 == _ULast1) {
                if (_Next2 == _ULast2) {
                    return _Check_match_counts(_UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred));
                }

                return false; 
            }

            if (_Next2 == _ULast2) {
                return false; 
            }
        }
    }
}

 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 {
    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 = _Unwrap_iter<_Se1>(::std:: move(_First1));
            auto _ULast1  = _Unwrap_sent<_It1>(::std:: move(_Last1));
            auto _UFirst2 = _Unwrap_iter<_Se2>(::std:: move(_First2));
            auto _ULast2  = _Unwrap_sent<_It2>(::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 901 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) -> bool {
                    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 980 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) -> bool {
                    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 1066 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1113 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1132 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 1174 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1194 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 1236 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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{}};































































#line 1360 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

     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()) {
                    _Result = _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), ::std:: move(_Result));
                    _UFirst += _Count;
                    _Seek_wrapped(_First, ::std:: move(_UFirst));
                    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 = _Unwrap_iter<_Se1>(::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 1422 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: copy_if(_First, _Last, _Dest, _Pass_fn(_Pred));
}
#line 1450 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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 = _Unwrap_iter<_Se1>(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It1>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Result = ::std::ranges:: _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     = ::std::ranges:: _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 1603 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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 1708 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 1709 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1740 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 1792 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::std:: move(_First));
            if constexpr (sized_sentinel_for<_Se, _It>) {
                const auto _Length = _Unwrap_sent<_It>(::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), _Unwrap_sent<_It>(::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 1914 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1922 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_random_iter_v<_FwdItHaystack> && _Is_ranges_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, _FwdItHaystack _First1, _FwdItHaystack _Last1, _FwdItPat _First2,
    _FwdItPat _Last2, _Pr _Pred) noexcept; 
#line 1985 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2001 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_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, _FwdIt _First, _FwdIt _Last, _Diff _Count_raw, const _Ty& _Val,
    _Pr _Pred) noexcept; 
#line 2087 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2101 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::std:: move(_First));
            auto _ULast  = _Unwrap_sent<_It>(::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(
                    _Unwrap_range_iter<_Rng>(_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{}};
























































































































































































































































































































































































































































































































































































































































































































#line 2957 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
} 
#line 2959 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_random_iter_v<_FwdIt1> && _Is_ranges_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_ranges_bidi_iter_v<_FwdIt1> && _Is_ranges_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 3059 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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] =
                        ::std::ranges:: _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 = _Unwrap_iter<_Se1>(_First1);
            auto _ULast1  = _Unwrap_sent<_It1>(_Last1);
            auto _UFirst2 = _Unwrap_iter<_Se2>(_First2);
            auto _ULast2  = _Unwrap_sent<_It2>(_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 3222 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _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_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 3263 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::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(_Unwrap_iter<_Se1>(::std:: move(_First1)), _Unwrap_sent<_It1>(::std:: move(_Last1)),
                    _Unwrap_iter<_Se2>(::std:: move(_First2)), _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)), _Uend(_Range1),
                _Unwrap_range_iter<_Rng2>(::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 {
                        do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 3400, 0, "%s", "Tried to swap_ranges with two unreachable sentinels")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Tried to swap_ranges with two unreachable sentinels\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 3400, 0); } while (false); } ; } while (false);
                    }
                }
            }
#line 3405 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3417 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    _Verify_ranges_do_not_overlap(_UFirst1, _ULast1, _UFirst2);
    _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 3438 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

 template <class _FwdIt1, class _FwdIt2>
constexpr void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right) { 
    swap(*_Left, *_Right); 
}

 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, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept; 
#line 3463 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt3 _Dest,
    _Fn _Func) noexcept; 
#line 3488 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)), _Uend(_Range1),
                _Unwrap_range_iter<_Rng2>(::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 3585 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3597 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _FwdIt _First, _FwdIt _Last, const _Ty& _Oldval,
    const _Ty& _Newval) noexcept; 
#line 3616 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(
                _Unwrap_range_iter<_Rng>(::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 3672 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3690 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(
                _Unwrap_range_iter<_Rng>(::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 3745 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: replace_copy(_First, _Last, _Dest, _Oldval, _Newval);
}
#line 3776 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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 3839 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: replace_copy_if(_First, _Last, _Dest, _Pass_fn(_Pred), _Val);
}
#line 3871 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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      = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _ULast = _Unwrap_sent<_It>(::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)(_Unwrap_range_iter<_Rng>(::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(_Unwrap_iter<_Se>(::std:: move(_First)),
                                      _Unwrap_sent<_Out>(::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(_Unwrap_range_iter<_Rng>(::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 4042 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4061 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_cpp17_fwd_iter_v<_FwdIt>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: generate_n(_Dest, _Count_raw, _Pass_fn(_Func));
}
#line 4089 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: remove_copy(_First, _Last, _Dest, _Val);
}
#line 4118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: remove_copy_if(_First, _Last, _Dest, _Pass_fn(_Pred));
}
#line 4147 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"


 template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] _FwdIt remove(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; 

 template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] _FwdIt remove_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 4155 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] constexpr subrange<_It> operator()(
            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Remove_unchecked(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] 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("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] constexpr subrange<_It> operator()(
            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Remove_if_unchecked(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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("The 'remove' and 'remove_if' algorithms return the iterator past the last element " "that should be kept. You need to call container.erase(result, container.end()) afterwards. " "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]] 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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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 4385 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

 template <class _FwdIt, class _Pr>
[[nodiscard("The 'unique' algorithm returns the iterator past the last element that should be kept. " "You need to call container.erase(result, container.end()) afterwards.")]] 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("The 'unique' algorithm returns the iterator past the last element that should be kept. " "You need to call container.erase(result, container.end()) afterwards.")]] 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("The 'unique' algorithm returns the iterator past the last element that should be kept. " "You need to call container.erase(result, container.end()) afterwards.")]] _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("The 'unique' algorithm returns the iterator past the last element that should be kept. " "You need to call container.erase(result, container.end()) afterwards.")]] _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    
    return ::std:: unique(_First, _Last);
}
#line 4431 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("The 'unique' algorithm returns the iterator past the last element that should be kept. " "You need to call container.erase(result, container.end()) afterwards.")]] constexpr subrange<_It> operator()(
            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Unique_unchecked(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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("The 'unique' algorithm returns the iterator past the last element that should be kept. " "You need to call container.erase(result, container.end()) afterwards.")]] 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 4498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

template <class _InIt, class _OutIt>

concept


#line 4505 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
    _Can_reread_dest = _Is_cpp17_fwd_iter_v<_OutIt> && is_same_v<_Iter_value_t<_InIt>, _Iter_value_t<_OutIt>>;

 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_ranges_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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.");
    return ::std:: unique_copy(_First, _Last, _Dest);
}
#line 4587 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::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>>>;

            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 4723 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::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 4756 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {

        if (!::std:: is_constant_evaluated())
#line 4777 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4794 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_BidIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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 = _Unwrap_iter<_Se>(::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);

                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 4882 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

            for (; _First != _Last; ++_Result) {
                *_Result = *--_Last;
            }

            return _Result;
        }
    };

     inline constexpr _Reverse_copy_fn reverse_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 4894 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 4895 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_iter<_Se>(::std:: move(_Mid)), _Unwrap_sent<_It>(::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), _Unwrap_range_iter<_Rng>(::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 5004 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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             = ::std:: _Copy_unchecked(_UMid, _ULast, _UDest);
    _Seek_wrapped(_Dest, ::std:: _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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt2>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_iter<_Se>(::std:: move(_Mid)), _Unwrap_sent<_It>(::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), _Unwrap_range_iter<_Rng>(::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 5081 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 5082 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

template <class _Diff, class _Urng>
class _Rng_from_urng { 
public:
    using _Ty0 = make_unsigned_t<_Diff>;
    using _Ty1 = _Invoke_result_t<_Urng&>;

    using _Udiff = conditional_t<sizeof(_Ty1) < sizeof(_Ty0), _Ty0, _Ty1>;

    explicit _Rng_from_urng(_Urng& _Func)
        : _Ref(_Func), _Bits(8 * sizeof(_Udiff)), _Bmask(static_cast<_Udiff>(-1)) {
        for (; static_cast<_Udiff>((_Urng::max)() - (_Urng::min)()) < _Bmask; _Bmask >>= 1) {
            --_Bits;
        }
    }

    _Diff operator()(_Diff _Index) { 
        for (;;) { 
            _Udiff _Ret  = 0; 
            _Udiff _Mask = 0; 

            while (_Mask < static_cast<_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 == static_cast<_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 (;;) { 
            const _Udiff _Val = static_cast<_Udiff>(_Ref() - (_Urng::min)());

            if (_Val <= _Bmask) {
                return _Val;
            }
        }
    }

    _Urng& _Ref; 
    size_t _Bits; 
    _Udiff _Bmask; 
};


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 _Urng>
_SampleIt sample(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count, _Urng&& _Func) {
    
    static_assert(_Is_ranges_fwd_iter_v<_PopIt> || _Is_cpp17_random_iter_v<_SampleIt>,
        "If the source range is not forward, the destination range must be a Cpp17RandomAccessIterator.");

    static_assert(is_integral_v<_Diff>, "The sample size must have an integer type.");
    _Adl_verify_range(_First, _Last);
    if (0 < _Count) {
        auto _UFirst   = _Get_unwrapped(_First);
        auto _ULast    = _Get_unwrapped(_Last);
        using _PopDiff = _Iter_diff_t<_PopIt>;
        _Rng_from_urng<_PopDiff, remove_reference_t<_Urng>> _RngFunc(_Func);
        if constexpr (_Is_ranges_fwd_iter_v<_PopIt>) {
            
            using _CT            = common_type_t<_Diff, _PopDiff>;
            const auto _Pop_size = ::std:: distance(_UFirst, _ULast);
            if (static_cast<_CT>(_Count) > static_cast<_CT>(_Pop_size)) {
                _Count = static_cast<_Diff>(_Pop_size); 
            }

            _Seek_wrapped(_Dest,
                _Sample_selection_unchecked(_UFirst, _Pop_size, _Get_unwrapped_n(_Dest, _Count), _Count, _RngFunc));
        } else {
            static_assert(_Is_ranges_input_iter_v<_PopIt>, "Source iterators must be at least input iterators");
            
            _Seek_wrapped(_Dest,
                _Sample_reservoir_unchecked(_UFirst, _ULast, _Get_unwrapped_unverified(_Dest), _Count, _RngFunc));
        }
    }

    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   = _Unwrap_iter<_Se>(::std:: move(_First));
                auto _Pop_size = ::std::ranges:: distance(_UFirst, _Unwrap_sent<_It>(::std:: move(_Last)));
                return _Sample_selection_unchecked(::std:: move(_UFirst), _Pop_size, ::std:: move(_Result), _Count, _RngFunc);
            } else {
                return _Sample_reservoir_unchecked(_Unwrap_iter<_Se>(::std:: move(_First)),
                    _Unwrap_sent<_It>(::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 5343 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 5344 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
        do { if (0 <= _Off && _Off <= _Target_index) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5360, 0, "%s", "random value out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"random value out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5360, 0); } while (false); } ; } while (false);
        if (_Off != _Target_index) { 
            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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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);
                do { if (0 <= _Off && _Off <= _Target_index) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5419, 0, "%s", "random value out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"random value out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5419, 0); } while (false); } ; } while (false);
                if (_Off != _Target_index) { 
                    ::std::ranges:: iter_swap(_Target, _First + _Off);
                }
            }
            return _Target;
        }
    };

     inline constexpr _Shuffle_fn shuffle{_Not_quite_object::_Construct_tag{}};
} 
#line 5431 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"





























#line 5461 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"


 template <class _FwdIt>
constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
    
    
    do { if (_Pos_to_shift >= 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5467, 0, "%s", "shift count must be non-negative (N4950 [alg.shift]/1)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"shift count must be non-negative (N4950 [alg.shift]/1)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5467, 0); } while (false); } ; } while (false);

    _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_cpp17_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, ::std:: _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) {
    
    
    do { if (_Pos_to_shift >= 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5508, 0, "%s", "shift count must be non-negative (N4950 [alg.shift]/5)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"shift count must be non-negative (N4950 [alg.shift]/5)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 5508, 0); } while (false); } ; } while (false);

    _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_cpp17_bidi_iter_v<_FwdIt>) {
        auto _UEnd_at = _ULast;
        if constexpr (_Is_cpp17_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) {
                ::std:: _Move_unchecked(_UFirst, _Trail, _UResult);

                return _First;
            }
        }

        
        

        for (;;) {
            
            
            for (auto _Mid = _UFirst; _Mid != _UResult; ++_Mid, (void) ++_Trail, ++_Lead) {
                if (_Lead == _ULast) {
                    _Trail = ::std:: _Move_unchecked(_Mid, _UResult, _Trail);
                    ::std:: _Move_unchecked(_UFirst, _Mid, _Trail);

                    return _First;
                }
                swap(*_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 5585 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"



































































































































































































































#line 5813 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_cpp17_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));

            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)) {
                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, _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(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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 5957 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 5958 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, ::std:: _Uninitialized_move_unchecked(_First, _Mid, _Temp_ptr)};
        const _BidIt _New_mid = ::std:: _Move_unchecked(_Mid, _Last, _First);
        ::std:: _Move_unchecked(_Backout._First, _Backout._Last, _New_mid);
        return _New_mid; 
    }

    if (_Count2 <= _Capacity) { 
        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{
            _Temp_ptr, ::std:: _Uninitialized_move_unchecked(_Mid, _Last, _Temp_ptr)};
        _Move_backward_unchecked(_First, _Mid, _Last);
        return ::std:: _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;
        ::std:: _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 6127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::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 6326 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 && _Debug_lt_pred(_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);
        ::std:: _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 = _Unwrap_iter<_Se>(::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 6433 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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;
    }

    ::std:: _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>;
    ::std:: _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);
        ::std:: _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);
    ::std:: _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 = _Unwrap_iter<_Se>(::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 6595 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
        ::std:: _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 = _Unwrap_iter<_Se>(::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 6669 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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, ::std:: _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 ::std:: _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      = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _ULast = _Unwrap_sent<_It>(::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     = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _Size = ::std::ranges:: distance(_UFirst, _Unwrap_sent<_It>(::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 6817 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 6818 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

template <class _RanIt, class _Pr>
constexpr void _Sort_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    for (; _Last - _First >= 2; --_Last) {
        ::std:: _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);

    const auto _Counterexample = ::std:: _Is_heap_until_unchecked(_UFirst, _ULast, _Pass_fn(_Pred));
    if (_Counterexample != _ULast) {
        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 6835, 0, "%s", "invalid heap in sort_heap()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid heap in sort_heap()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 6835, 0); } while (false);
    }
#line 6838 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::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      = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _Count = ::std::ranges:: distance(_UFirst, _Unwrap_sent<_It>(::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));
            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }
    };

     inline constexpr _Lower_bound_fn lower_bound{_Not_quite_object::_Construct_tag{}};

    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      = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _Count = ::std::ranges:: distance(_UFirst, _Unwrap_sent<_It>(::std:: move(_Last)));
            _UFirst =
                ::std::ranges:: _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 =
                ::std::ranges:: _Upper_bound_unchecked(_Ubegin(_Range), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }
    };

     inline constexpr _Upper_bound_fn upper_bound{_Not_quite_object::_Construct_tag{}};
} 
#line 6995 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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      = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _Count = ::std::ranges:: distance(_UFirst, _Unwrap_sent<_It>(::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 7101 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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      = _Unwrap_iter<_Se>(::std:: move(_First));
            const auto _ULast = _Unwrap_sent<_It>(::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 7150 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    _Debug_order_set_unchecked<_InIt2>(_UFirst1, _ULast1, _Pred);
    _Debug_order_set_unchecked<_InIt1>(_UFirst2, _ULast2, _Pred);
    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 (_Debug_lt_pred(_Pred, *_UFirst2, *_UFirst1)) {
                *_UDest = *_UFirst2;
                ++_UDest;
                ++_UFirst2;

                if (_UFirst2 == _ULast2) {
                    break;
                }
            } else {
                *_UDest = *_UFirst1;
                ++_UDest;
                ++_UFirst1;

                if (_UFirst1 == _ULast1) {
                    break;
                }
            }
        }
    }

    _UDest = ::std:: _Copy_unchecked(_UFirst1, _ULast1, _UDest); 
    _Seek_wrapped(_Dest, ::std:: _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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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(_Unwrap_iter<_Se1>(::std:: move(_First1)), _Unwrap_sent<_It1>(::std:: move(_Last1)),
                    _Unwrap_iter<_Se2>(::std:: move(_First2)), _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)), _Uend(_Range1),
                _Unwrap_range_iter<_Rng2>(::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 7320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 7321 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    *::std:: _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, ::std:: _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) {
                ::std:: _Move_unchecked(_Left_first, _Backout._Last, _First); 
                return;
            }
        } else { 
            *_First = ::std:: move(*_Left_first);
            ++_First;
            ++_Left_first;
            if (_Left_first == _Left_last) {
                
                *::std:: _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, ::std:: _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>* _Temp_ptr, 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);
        ::std:: _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);
        ::std:: _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) {
        ::std:: _Inplace_merge_buffer_left(_First, _Mid, _Last, _Temp_ptr, _Pred);
    } else if (_Count2 <= _Capacity) {
        ::std:: _Inplace_merge_buffer_right(_First, _Mid, _Last, _Temp_ptr, _Pred);
    } else {
        ::std:: _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) {
            ::std:: _Rotate_one_right(_First, _Mid, ++_Last);
            return;
        }
    } while (!_Pred(*_Last, *_Highest));

    ++_Last;
    ++_Count2;

    if (_Count1 == 1) {
        ::std:: _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);
    _Debug_order_unchecked(_UFirst, _UMid, _Pred);

    
    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) { 
            ::std:: _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) { 
        ::std:: _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 7585 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);

            _Inplace_merge_common(::std:: move(_UFirst), _Unwrap_iter<_Se>(::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 = _Unwrap_range_iter<_Rng>(::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), _Unwrap_range_iter<_Rng>(::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;
            }

            do { if (::std::ranges:: _Is_sorted_until_unchecked(_First, _Mid, _Pred, _Proj) == _Mid) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 7853, 0, "%s", "ranges::inplace_merge requires the range [first, middle) to be sorted")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"ranges::inplace_merge requires the range [first, middle) to be sorted\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 7853, 0); } while (false); } ; } while (false);
#line 7854 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
            do { if (::std::ranges:: _Is_sorted_until_unchecked(_Mid, _Last, _Pred, _Proj) == _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 7855, 0, "%s", "ranges::inplace_merge requires the range [middle, last) to be sorted")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"ranges::inplace_merge requires the range [middle, last) to be sorted\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 7855, 0); } while (false); } ; } while (false);
#line 7856 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 7857 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 7907 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, _Val, *_First)) { 
                _Move_backward_unchecked(_First, _Mid, ++_Hole);
                *_First = ::std:: move(_Val);
            } else { 
                for (_BidIt _Prev = _Hole; _Debug_lt_pred(_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 (_Debug_lt_pred(_Pred, *_Mid, *_First)) {
        swap(*_Mid, *_First); 
    }

    if (_Debug_lt_pred(_Pred, *_Last, *_Mid)) { 
        swap(*_Last, *_Mid); 

        if (_Debug_lt_pred(_Pred, *_Mid, *_First)) {
            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 && !_Debug_lt_pred(_Pred, *_Prev_iter(_Pfirst), *_Pfirst)
           && !_Pred(*_Pfirst, *_Prev_iter(_Pfirst))) {
        --_Pfirst;
    }

    while (_Plast < _Last && !_Debug_lt_pred(_Pred, *_Plast, *_Pfirst) && !_Pred(*_Pfirst, *_Plast)) {
        ++_Plast;
    }

    _RanIt _Gfirst = _Plast;
    _RanIt _Glast  = _Pfirst;

    for (;;) { 
        for (; _Gfirst < _Last; ++_Gfirst) {
            if (_Debug_lt_pred(_Pred, *_Pfirst, *_Gfirst)) {
                continue;
            } else if (_Pred(*_Gfirst, *_Pfirst)) {
                break;
            } else if (_Plast != _Gfirst) {
                swap(*_Plast, *_Gfirst); 
                ++_Plast;
            } else {
                ++_Plast;
            }
        }

        for (; _First < _Glast; --_Glast) {
            const auto _Glast_prev = _Prev_iter(_Glast);
            if (_Debug_lt_pred(_Pred, *_Glast_prev, *_Pfirst)) {
                continue;
            } else if (_Pred(*_Pfirst, *_Glast_prev)) {
                break;
            } else if (--_Pfirst != _Glast_prev) {
                swap(*_Pfirst, *_Glast_prev); 
            }
        }

        if (_Glast == _First && _Gfirst == _Last) {
            return pair<_RanIt, _RanIt>(_Pfirst, _Plast);
        }

        if (_Glast == _First) { 
            if (_Plast != _Gfirst) {
                swap(*_Pfirst, *_Plast); 
            }

            ++_Plast;
            swap(*_Pfirst, *_Gfirst); 
            ++_Pfirst;
            ++_Gfirst;
        } else if (_Gfirst == _Last) { 
            if (--_Glast != --_Pfirst) {
                swap(*_Glast, *_Pfirst); 
            }

            swap(*_Pfirst, *--_Plast); 
        } else {
            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 8089 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::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) { 
                    ::std::ranges:: _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 8284 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
                auto _Mid       = _Partition_by_median_guess_common(_First, _Last, _Pred, _Proj);
                auto _Mid_first = _Mid.begin();
                auto _Mid_last  = _Mid.end();
#line 8288 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 8305 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, *_Next, *_First)) {
            _Backout._Emplace_back(::std:: move(*_Next));
            ++_Next;

            if (_Next == _Last) {
                _Backout._Last = ::std:: _Uninitialized_move_unchecked(_First, _Mid, _Backout._Last);
                return _Backout._Release();
            }
        } else {
            _Backout._Emplace_back(::std:: move(*_First));
            ++_First;

            if (_First == _Mid) {
                _Backout._Last = ::std:: _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 (_Debug_lt_pred(_Pred, *_Next, *_First)) {
            *_Dest = ::std:: move(*_Next);
            ++_Dest;
            ++_Next;

            if (_Next == _Last) {
                return ::std:: _Move_unchecked(_First, _Mid, _Dest);
            }
        } else {
            *_Dest = ::std:: move(*_First);
            ++_Dest;
            ++_First;

            if (_First == _Mid) {
                return ::std:: _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;
    }

    ::std:: _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;
    }

    ::std:: _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, _BidIt _First, _BidIt _Last, _Pr _Pred) noexcept; 
#line 8485 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 8498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = _Unwrap_iter<_Se>(::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 8751 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, *_UNext, *_UFirst)) { 
            _Iter_value_t<_RanIt> _Val = ::std:: move(*_UNext);
            ::std:: _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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_iter<_Se>(::std:: move(_Mid)),
                    _Unwrap_sent<_It>(_Last), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Last;
            } else {
                auto _UMid  = _Unwrap_iter<_Se>(::std:: move(_Mid));
                auto _ULast = _Get_final_iterator_unwrapped<_It>(_UMid, ::std:: move(_Last));
                _Seek_wrapped(_Mid, _ULast);
                _Partial_sort_common(_Unwrap_iter<_Se>(::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), _Unwrap_range_iter<_Rng>(::std:: move(_Mid)), _Uend(_Range),
                    _Pass_fn(_Pred), _Pass_fn(_Proj));
                return ::std::ranges:: end(_Range);
            } else {
                auto _UMid  = _Unwrap_range_iter<_Rng>(::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 8870 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 8871 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, *_UFirst1, *_UFirst2)) {
                
                using _Diff = _Iter_diff_t<_RanIt>;
                ::std:: _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_ranges_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_RanIt>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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_ranges_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_RanIt>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::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 9018 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9019 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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   = _Unwrap_iter<_Se>(_Nth);
            auto _UFinal = _Get_final_iterator_unwrapped<_It>(_UNth, ::std:: move(_Last));
            _Seek_wrapped(_Nth, _UFinal);

            _Nth_element_common(_Unwrap_iter<_Se>(::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   = _Unwrap_range_iter<_Rng>(_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();
                }
            }

            
            ::std::ranges:: _Insertion_sort_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
        }
    };

     inline constexpr _Nth_element_fn nth_element{_Not_quite_object::_Construct_tag{}};
} 
#line 9140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9141 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    _Debug_order_set_unchecked<_InIt2>(_UFirst1, _ULast1, _Pred);
    _Debug_order_set_unchecked<_InIt1>(_UFirst2, _ULast2, _Pred);
    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UFirst1) {
        if (_Debug_lt_pred(_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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_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(_Unwrap_iter<_Se1>(::std:: move(_First1)), _Unwrap_sent<_It1>(::std:: move(_Last1)),
                _Unwrap_iter<_Se2>(::std:: move(_First2)), _Unwrap_sent<_It2>(::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 9264 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    _Debug_order_set_unchecked<_InIt2>(_UFirst1, _ULast1, _Pred);
    _Debug_order_set_unchecked<_InIt1>(_UFirst2, _ULast2, _Pred);
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UDest) {
        if (_Debug_lt_pred(_Pred, *_UFirst1, *_UFirst2)) { 
            *_UDest = *_UFirst1;
            ++_UFirst1;
        } else if (_Pred(*_UFirst2, *_UFirst1)) { 
            *_UDest = *_UFirst2;
            ++_UFirst2;
        } else { 
            *_UDest = *_UFirst1;
            ++_UFirst1;
            ++_UFirst2;
        }
    }

    _UDest = ::std:: _Copy_unchecked(_UFirst1, _ULast1, _UDest);
    _Seek_wrapped(_Dest, ::std:: _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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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(_Unwrap_iter<_Se1>(::std:: move(_First1)), _Unwrap_sent<_It1>(::std:: move(_Last1)),
                    _Unwrap_iter<_Se2>(::std:: move(_First2)), _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)), _Uend(_Range1),
                _Unwrap_range_iter<_Rng2>(::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 9403 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9404 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    _Debug_order_set_unchecked<_InIt2>(_UFirst1, _ULast1, _Pred);
    _Debug_order_set_unchecked<_InIt1>(_UFirst2, _ULast2, _Pred);
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        if (_Debug_lt_pred(_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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)), _Uend(_Range1),
                _Unwrap_range_iter<_Rng2>(::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 9536 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9537 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    _Debug_order_set_unchecked<_InIt2>(_UFirst1, _ULast1, _Pred);
    _Debug_order_set_unchecked<_InIt1>(_UFirst2, _ULast2, _Pred);
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        if (_Debug_lt_pred(_Pred, *_UFirst1, *_UFirst2)) { 
            *_UDest = *_UFirst1;
            ++_UDest;
            ++_UFirst1;
        } else {
            if (!_Pred(*_UFirst2, *_UFirst1)) {
                ++_UFirst1;
            }

            ++_UFirst2;
        }
    }

    _Seek_wrapped(_Dest, ::std:: _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(_Unwrap_iter<_Se1>(::std:: move(_First1)), _Unwrap_sent<_It1>(::std:: move(_Last1)),
                    _Unwrap_iter<_Se2>(::std:: move(_First2)), _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::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 9666 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9667 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    _Debug_order_set_unchecked<_InIt2>(_UFirst1, _ULast1, _Pred);
    _Debug_order_set_unchecked<_InIt1>(_UFirst2, _ULast2, _Pred);
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        if (_Debug_lt_pred(_Pred, *_UFirst1, *_UFirst2)) { 
            *_UDest = *_UFirst1;
            ++_UDest;
            ++_UFirst1;
        } else if (_Pred(*_UFirst2, *_UFirst1)) { 
            *_UDest = *_UFirst2;
            ++_UDest;
            ++_UFirst2;
        } else { 
            ++_UFirst1;
            ++_UFirst2;
        }
    }

    _UDest = ::std:: _Copy_unchecked(_UFirst1, _ULast1, _UDest);
    _Seek_wrapped(_Dest, ::std:: _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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_cpp17_fwd_iter_v<_FwdIt3>, "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators 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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                _Unwrap_sent<_It2>(::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(_Unwrap_range_iter<_Rng1>(::std:: move(_First1)),
                _Uend(_Range1), _Unwrap_range_iter<_Rng2>(::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 9819 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 9820 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

template <class _FwdIt, class _Pr>
constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {

    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
        if (!_Is_constant_evaluated()) {
            const auto _First_ptr = _To_address(_First);
            const auto _Result    = __std_minmax_element(_First_ptr, _To_address(_Last));
            if constexpr (is_pointer_v<_FwdIt>) {
                return _Result;
            } else {
                return {_First + (_Result.first - _First_ptr), _First + (_Result.second - _First_ptr)};
            }
        }
    }
#line 9836 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

    
    pair<_FwdIt, _FwdIt> _Found(_First, _First);

    if (_First != _Last) {
        while (++_First != _Last) { 
            _FwdIt _Next = _First;
            if (++_Next == _Last) { 
                if (_Debug_lt_pred(_Pred, *_First, *_Found.first)) {
                    _Found.first = _First;
                } else if (!_Debug_lt_pred(_Pred, *_First, *_Found.second)) {
                    _Found.second = _First;
                }
            } else { 
                if (_Debug_lt_pred(_Pred, *_Next, *_First)) { 
                    if (_Debug_lt_pred(_Pred, *_Next, *_Found.first)) {
                        _Found.first = _Next;
                    }

                    if (!_Debug_lt_pred(_Pred, *_First, *_Found.second)) {
                        _Found.second = _First;
                    }
                } else { 
                    if (_Debug_lt_pred(_Pred, *_First, *_Found.first)) {
                        _Found.first = _First;
                    }

                    if (!_Debug_lt_pred(_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 = ::std:: _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>;

    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 {
            ::std:: _Adl_verify_range(_First, _Last);
            auto _UResult = _Minmax_element_fwd_unchecked(::std::ranges:: _Unwrap_iter<_Se>(::std:: move(_First)),
                ::std::ranges:: _Unwrap_sent<_It>(::std:: move(_Last)), ::std:: _Pass_fn(_Pred), ::std:: _Pass_fn(_Proj));
            ::std:: _Seek_wrapped(_First, ::std:: move(_UResult.min));
            auto _Second = _First;
            ::std:: _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 _UResult = _Minmax_element_fwd_unchecked(
                ::std::ranges:: _Ubegin(_Range), ::std::ranges:: _Uend(_Range), ::std:: _Pass_fn(_Pred), ::std:: _Pass_fn(_Proj));
            return {
                _Rewrap_iterator(_Range, ::std:: move(_UResult.min)), _Rewrap_iterator(_Range, ::std:: move(_UResult.max))};
        }

    private:
        template <class _It, class _Se, class _Pr, class _Pj>
        [[nodiscard]] static constexpr min_max_result<_It> _Minmax_element_fwd_unchecked(
            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;


            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
                          && sized_sentinel_for<_Se, _It>) {
                if (!::std:: is_constant_evaluated()) {
                    const auto _First_ptr = ::std:: to_address(_First);
                    const auto _Last_ptr  = _First_ptr + (_Last - _First);
                    const auto _Result    = :: __std_minmax_element(_First_ptr, _Last_ptr);
                    if constexpr (is_pointer_v<_It>) {
                        return {_Result.first, _Result.second};
                    } else {
                        return {_First + (_Result.first - _First_ptr), _First + (_Result.second - _First_ptr)};
                    }
                }
            }
#line 9962 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

            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;
        }
    };

     inline constexpr _Minmax_element_fn minmax_element{_Not_quite_object::_Construct_tag{}};
} 
#line 10009 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 10010 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

 template <class _Ty, class _Pr>
[[nodiscard]] constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left [[msvc::lifetimebound]],
    const _Ty& _Right [[msvc::lifetimebound]],
    _Pr _Pred) noexcept(noexcept(_Debug_lt_pred(_Pred, _Right, _Left)))  {
    
    if (_Debug_lt_pred(_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 = ::std:: _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 [[msvc::lifetimebound]],
    const _Ty& _Right [[msvc::lifetimebound]]) noexcept(noexcept(_Right < _Left))  {
    
    if (_Right < _Left) {
        do { if (!(_Left < _Right)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10035, 0, "%s", "invalid comparator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid comparator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10035, 0); } while (false); } ; } while (false);
        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 [[msvc::lifetimebound]],
            const _Ty& _Right [[msvc::lifetimebound]], _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();
            do { if (_First != _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10075, 0, "%s", "An initializer_list passed to std::ranges::minmax must not be empty. (N4950 [alg.min.max]/21)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"An initializer_list passed to std::ranges::minmax must not be empty. (N4950 [alg.min.max]/21)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10075, 0); } while (false); } ; } while (false);
#line 10076 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
            return _Minmax_fwd_unchecked(_First, _Last, ::std:: _Pass_fn(_Pred), ::std:: _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 minmax_result<range_value_t<_Rng>> operator()(
            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _UFirst = ::std::ranges:: _Ubegin(_Range);
            auto _ULast  = ::std::ranges:: _Uend(_Range);
            do { if (_UFirst != _ULast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10087, 0, "%s", "A range passed to std::ranges::minmax must not be empty. (N4950 [alg.min.max]/21)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"A range passed to std::ranges::minmax must not be empty. (N4950 [alg.min.max]/21)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10087, 0); } while (false); } ; } while (false);
#line 10088 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<iterator_t<_Rng>>) {
                return _Minmax_fwd_unchecked(
                    ::std:: move(_UFirst), ::std:: move(_ULast), ::std:: _Pass_fn(_Pred), ::std:: _Pass_fn(_Proj));
            } else {
                using _Vty = range_value_t<_Rng>;
                
                minmax_result<_Vty> _Found = {static_cast<_Vty>(*_UFirst), _Found.min};
                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;
            }
        }

    private:
        template <class _It, class _Se, class _Pr, class _Pj>
        [[nodiscard]] static constexpr minmax_result<iter_value_t<_It>> _Minmax_fwd_unchecked(
            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            ;

            using _Vty = iter_value_t<_It>;

            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
                          && sized_sentinel_for<_Se, _It>) {
                if (!::std:: is_constant_evaluated()) {
                    const auto _First_ptr = ::std:: to_address(_First);
                    const auto _Last_ptr  = _First_ptr + (_Last - _First);
                    const auto _Result    = :: __std_minmax_element(_First_ptr, _Last_ptr);
                    return {static_cast<_Vty>(*_Result.first), static_cast<_Vty>(*_Result.second)};
                }
            }
#line 10158 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

            auto _Found_min = _First;
            if (++_First == _Last) {
                
                minmax_result<_Vty> _Result = {static_cast<_Vty>(*_Found_min), _Result.min};
                return _Result;
            }

            auto _Found_max = _First;
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Found_max), ::std:: invoke(_Proj, *_Found_min))) {
                ::std::ranges:: swap(_Found_min, _Found_max);
            }

            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 {static_cast<_Vty>(*_Found_min), static_cast<_Vty>(*_Found_max)};
        }
    };

     inline constexpr _Minmax_fn minmax{_Not_quite_object::_Construct_tag{}};
} 
#line 10211 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, *--_UNext, *_UNext1)) { 
            auto _UMid = _ULast;
            do {
                --_UMid;
            } while (!_Debug_lt_pred(_Pred, *_UNext, *_UMid));

            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 = _Unwrap_iter<_Se>(::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 10315 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, *_UNext1, *--_UNext)) { 
            auto _UMid = _ULast;
            do {
                --_UMid;
            } while (!_Debug_lt_pred(_Pred, *_UMid, *_UNext));

            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 = _Unwrap_iter<_Se>(::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 10419 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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  = _Unwrap_sent<_It>(::std:: move(_Last));
            const auto _UFirst = ::std::ranges:: _Is_sorted_until_unchecked(
                _Unwrap_iter<_Se>(::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 =
                ::std::ranges:: _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 = ::std::ranges:: _Is_sorted_until_unchecked(_Unwrap_iter<_Se>(::std:: move(_First)),
                _Unwrap_sent<_It>(::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 _UResult =
                ::std::ranges:: _Is_sorted_until_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }
    };

     inline constexpr _Is_sorted_until_fn is_sorted_until{_Not_quite_object::_Construct_tag{}};
} 
#line 10535 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

 template <class _Ty, class _Pr>
[[nodiscard]] constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, const _Ty& _Max_val, _Pr _Pred) {
    

    if (_Debug_lt_pred(_Pred, _Max_val, _Min_val)) {
        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10541, 0, "%s", "invalid bounds arguments passed to std::clamp")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid bounds arguments passed to std::clamp\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10541, 0); } while (false);
        return _Val;
    }
#line 10545 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

    if constexpr (conjunction_v<is_scalar<_Ty>, disjunction<is_same<_Pr, less<>>, is_same<_Pr, less<_Ty>>>>) {
        
        const _Ty& _Tmp = _Debug_lt_pred(_Pred, _Val, _Min_val) ? _Min_val : _Val;
        return _Debug_lt_pred(_Pred, _Max_val, _Val) ? _Max_val : _Tmp;
    } else {

        if (_Debug_lt_pred(_Pred, _Max_val, _Val)) {
            return _Max_val;
        }

        if (_Debug_lt_pred(_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 {
            do { if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, _Hi), ::std:: invoke(_Proj, _Lo))) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10582, 0, "%s", "The lower bound cannot be greater than the upper bound in a call to std::ranges::clamp " "(N4950 [alg.clamp]/2).")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"The lower bound cannot be greater than the upper bound in a call to std::ranges::clamp \" \"(N4950 [alg.clamp]/2).\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm", 10582, 0); } while (false); } ; } while (false);
#line 10583 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Unwrap_iter<_Se1>(::std:: move(_First1)),
                _Unwrap_sent<_It1>(::std:: move(_Last1)), _Unwrap_iter<_Se2>(::std:: move(_First2)),
                _Unwrap_sent<_It2>(::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 = 0xffffffffffffffffui64;
                    }

                    size_t _Num2;
                    if constexpr (_Is_sized2) {
                        _Num2 = static_cast<size_t>(_Last2 - _First2);
                    } else {
                        _Num2 = 0xffffffffffffffffui64;
                    }

                    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 10680 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 10681 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"

}







#pragma warning(pop)
#pragma pack(pop)
#line 10693 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#line 10694 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\algorithm"
#pragma external_header(pop)
#line 143 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"











#line 155 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 158 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"














































#line 205 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"









#line 215 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"







#line 223 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"










typedef signed char qint8;         
typedef unsigned char quint8;      
typedef short qint16;              
typedef unsigned short quint16;    
typedef int qint32;                
typedef unsigned int quint32;      



typedef __int64 qint64;            
typedef unsigned __int64 quint64;  










#line 255 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

typedef qint64 qlonglong;
typedef quint64 qulonglong;















typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;




#line 282 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
typedef double qreal;
#line 284 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"






#line 291 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



















#line 311 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"






#line 318 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 319 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"





















#line 341 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"














#line 356 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"







#line 364 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"







#line 372 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"







#line 380 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"







#line 388 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"









namespace QtPrivate {
enum class Deprecated_t {};
constexpr  Deprecated_t Deprecated = {};
}
#line 402 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

























#line 428 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 431 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 433 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 436 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

























#line 462 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 464 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 466 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

















extern "C"
#line 485 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
__declspec(dllimport)  const char *qVersion(void) noexcept;












#line 499 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"










#line 510 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

namespace QtPrivate {
    template <class T>
    struct AlignOfHelper
    {
        char c;
        T type;

        AlignOfHelper();
        ~AlignOfHelper();
    };

    template <class T>
    struct AlignOf_Default
    {
        enum { Value = sizeof(AlignOfHelper<T>) - sizeof(T) };
    };

    template <class T> struct AlignOf : AlignOf_Default<T> { };
    template <class T> struct AlignOf<T &> : AlignOf<T> {};
    template <class T> struct AlignOf<T &&> : AlignOf<T> {};
    template <size_t N, class T> struct AlignOf<T[N]> : AlignOf<T> {};















#line 548 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
} 


















template <int> struct QIntegerForSize;
template <>    struct QIntegerForSize<1> { typedef quint8  Unsigned; typedef qint8  Signed; };
template <>    struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
template <>    struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
template <>    struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };


#line 575 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
typedef QIntegerForSize<8>::Signed qregisterint;
typedef QIntegerForSize<8>::Unsigned qregisteruint;
typedef QIntegerForSizeof<void*>::Unsigned quintptr;
typedef QIntegerForSizeof<void*>::Signed qptrdiff;
typedef qptrdiff qintptr;
using qsizetype = QIntegerForSizeof<std::size_t>::Signed;







#line 590 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"





#line 596 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"











#line 608 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"










#line 619 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 621 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"










#line 632 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"




#line 637 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 639 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"






#line 646 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 648 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 650 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

typedef int QNoImplicitBoolCast;





template <typename T>
constexpr inline T qAbs(const T &t) { return t >= 0 ? t : -t; }

constexpr inline int qRound(double d)
{ return d >= 0.0 ? int(d + 0.5) : int(d - double(int(d-1)) + 0.5) + int(d-1); }
constexpr inline int qRound(float d)
{ return d >= 0.0f ? int(d + 0.5f) : int(d - float(int(d-1)) + 0.5f) + int(d-1); }

constexpr inline qint64 qRound64(double d)
{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - double(qint64(d-1)) + 0.5) + qint64(d-1); }
constexpr inline qint64 qRound64(float d)
{ return d >= 0.0f ? qint64(d + 0.5f) : qint64(d - float(qint64(d-1)) + 0.5f) + qint64(d-1); }

template <typename T>
constexpr inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; }
template <typename T>
constexpr inline const T &qMax(const T &a, const T &b) { return (a < b) ? b : a; }
template <typename T>
constexpr inline const T &qBound(const T &min, const T &val, const T &max)
{ return qMax(min, qMin(max, val)); }






#line 684 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 685 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 688 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 691 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 694 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 697 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

































































#line 763 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"





class QDataStream;

inline void qt_noop(void) {}













#line 786 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


#line 789 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 790 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"












__declspec(noreturn)  __declspec(dllimport) void qTerminate() noexcept;




#line 808 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 809 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

__declspec(dllimport)  bool qSharedBuild() noexcept;






#line 818 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"







#line 826 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"




#line 831 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



#line 835 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"








#line 844 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

class QString;

__declspec(dllimport) QString qt_error_string(int errorCode = -1);





__declspec(dllimport) void qt_assert(const char *assertion, const char *file, int line) noexcept;




#line 859 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 861 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 862 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"





__declspec(dllimport) void qt_assert_x(const char *where, const char *what, const char *file, int line) noexcept;




#line 873 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 875 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 876 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

__declspec(noreturn) __declspec(dllimport) void qt_check_pointer(const char *, int) noexcept;

__declspec(dllimport) void qBadAlloc();









#line 890 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

template <typename T>
inline T *q_check_ptr(T *p) { do { if (!(p)) qBadAlloc(); } while (false); return p; }

typedef void (*QFunctionPointer)();



#line 899 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

[[nodiscard]] constexpr static inline  bool qFuzzyCompare(double p1, double p2)
{
    return (qAbs(p1 - p2) * 1000000000000. <= qMin(qAbs(p1), qAbs(p2)));
}

[[nodiscard]] constexpr static inline  bool qFuzzyCompare(float p1, float p2)
{
    return (qAbs(p1 - p2) * 100000.f <= qMin(qAbs(p1), qAbs(p2)));
}

[[nodiscard]] constexpr static inline  bool qFuzzyIsNull(double d)
{
    return qAbs(d) <= 0.000000000001;
}

[[nodiscard]] constexpr static inline   bool qFuzzyIsNull(float f)
{
    return qAbs(f) <= 0.00001f;
}

__pragma(warning(push))




[[nodiscard]] constexpr static inline  bool qIsNull(double d) noexcept
{
    return d == 0.0;
}

[[nodiscard]] constexpr static inline  bool qIsNull(float f) noexcept
{
    return f == 0.0f;
}

__pragma(warning(pop))



















#line 956 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

__pragma(warning(push))



namespace QtPrivate
{
namespace SwapExceptionTester { 
    using std::swap; 
    template <typename T>
    void checkSwap(T &t)
        noexcept(noexcept(swap(t, t)));
    
}
} 

template <typename T>
inline void qSwap(T &value1, T &value2)
    noexcept(noexcept(QtPrivate::SwapExceptionTester::checkSwap(value1)))
{
    using std::swap;
    swap(value1, value2);
}

__pragma(warning(pop))







#line 989 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
__declspec(dllimport) void *qMallocAligned(size_t size, size_t alignment) ;
__declspec(dllimport) void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment) ;
__declspec(dllimport) void qFreeAligned(void *ptr);









#line 1002 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


__pragma(warning(disable: 4251)) 
__pragma(warning(disable: 4244)) 
__pragma(warning(disable: 4275)) 
__pragma(warning(disable: 4514)) 
__pragma(warning(disable: 4800)) 
__pragma(warning(disable: 4097)) 
__pragma(warning(disable: 4706)) 
__pragma(warning(disable: 4355)) 
__pragma(warning(disable: 4710)) 
__pragma(warning(disable: 4530)) 








#line 1023 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 1024 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"















#line 1040 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
template <typename ForwardIterator1, typename ForwardIterator2>
inline bool qt_is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2, ForwardIterator2 last2)
{
    return std::is_permutation(first1, last1, first2, last2);
}



template <typename T>
constexpr typename std::add_const<T>::type &qAsConst(T &t) noexcept { return t; }

template <typename T>
void qAsConst(const T &&) = delete;


template <typename T, typename U = T>
constexpr T qExchange(T &t, U &&newValue)
{
    T old = std::move(t);
    t = std::forward<U>(newValue);
    return old;
}



namespace QtPrivate {

template <typename T>
class QForeachContainer {
    QForeachContainer(const QForeachContainer &) = delete; QForeachContainer &operator=(const QForeachContainer &) = delete;
public:
    QForeachContainer(const T &t) : c(t), i(qAsConst(c).begin()), e(qAsConst(c).end()) {}
    QForeachContainer(T &&t) : c(std::move(t)), i(qAsConst(c).begin()), e(qAsConst(c).end())  {}

    QForeachContainer(QForeachContainer &&other)
        : c(std::move(other.c)),
          i(qAsConst(c).begin()),
          e(qAsConst(c).end()),
          control(std::move(other.control))
    {
    }

    QForeachContainer &operator=(QForeachContainer &&other)
    {
        c = std::move(other.c);
        i = qAsConst(c).begin();
        e = qAsConst(c).end();
        control = std::move(other.control);
        return *this;
    }

    T c;
    typename T::const_iterator i, e;
    int control = 1;
};

template<typename T>
QForeachContainer<typename std::decay<T>::type> qMakeForeachContainer(T &&t)
{
    return QForeachContainer<typename std::decay<T>::type>(std::forward<T>(t));
}

}


























#line 1131 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



#line 1135 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"













template <typename T> inline T *qGetPtrHelper(T *ptr) { return ptr; }
template <typename Ptr> inline auto qGetPtrHelper(Ptr &ptr) -> decltype(ptr.operator->()) { return ptr.operator->(); }









































__declspec(dllimport) QString qtTrId(const char *id, int n = -1);



#line 1196 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"














template <typename... Args>
struct QNonConstOverload
{
    template <typename R, typename T>
    constexpr auto operator()(R (T::*ptr)(Args...)) const noexcept -> decltype(ptr)
    { return ptr; }

    template <typename R, typename T>
    static constexpr auto of(R (T::*ptr)(Args...)) noexcept -> decltype(ptr)
    { return ptr; }
};

template <typename... Args>
struct QConstOverload
{
    template <typename R, typename T>
    constexpr auto operator()(R (T::*ptr)(Args...) const) const noexcept -> decltype(ptr)
    { return ptr; }

    template <typename R, typename T>
    static constexpr auto of(R (T::*ptr)(Args...) const) noexcept -> decltype(ptr)
    { return ptr; }
};

template <typename... Args>
struct QOverload : QConstOverload<Args...>, QNonConstOverload<Args...>
{
    using QConstOverload<Args...>::of;
    using QConstOverload<Args...>::operator();
    using QNonConstOverload<Args...>::of;
    using QNonConstOverload<Args...>::operator();

    template <typename R>
    constexpr auto operator()(R (*ptr)(Args...)) const noexcept -> decltype(ptr)
    { return ptr; }

    template <typename R>
    static constexpr auto of(R (*ptr)(Args...)) noexcept -> decltype(ptr)
    { return ptr; }
};


template <typename... Args> constexpr  QOverload<Args...> qOverload = {};
template <typename... Args> constexpr  QConstOverload<Args...> qConstOverload = {};
template <typename... Args> constexpr  QNonConstOverload<Args...> qNonConstOverload = {};
#line 1256 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 1258 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"


class QByteArray;
__declspec(dllimport) QByteArray qgetenv(const char *varName);

__declspec(dllimport) QString qEnvironmentVariable(const char *varName);
__declspec(dllimport) QString qEnvironmentVariable(const char *varName, const QString &defaultValue);
__declspec(dllimport) bool qputenv(const char *varName, const QByteArray& value);
__declspec(dllimport) bool qunsetenv(const char *varName);

__declspec(dllimport) bool qEnvironmentVariableIsEmpty(const char *varName) noexcept;
__declspec(dllimport) bool qEnvironmentVariableIsSet(const char *varName) noexcept;
__declspec(dllimport) int  qEnvironmentVariableIntValue(const char *varName, bool *ok=nullptr) noexcept;

inline int qIntCast(double f) { return int(f); }
inline int qIntCast(float f) { return int(f); }







#line 1282 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"






#line 1290 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

namespace QtPrivate {

template <bool B, typename T = void> struct QEnableIf;
template <typename T> struct QEnableIf<true, T> { typedef T Type; };
}





#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"










template <typename T>
static constexpr bool qIsRelocatable()
{

    return std::is_trivially_copyable<T>::value && std::is_trivially_destructible<T>::value;


#line 60 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"
}

template <typename T>
static constexpr bool qIsTrivial()
{

    return std::is_trivial<T>::value;


#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"
}





template <typename T>
class QTypeInfo
{
public:
    enum {
        isSpecialized = std::is_enum<T>::value, 
        isPointer = false,
        isIntegral = std::is_integral<T>::value,
        isComplex = !qIsTrivial<T>(),
        isStatic = true,
        isRelocatable = qIsRelocatable<T>(),
        isLarge = (sizeof(T)>sizeof(void*)),
        isDummy = false, 
        sizeOf = sizeof(T)
    };
};

template<>
class QTypeInfo<void>
{
public:
    enum {
        isSpecialized = true,
        isPointer = false,
        isIntegral = false,
        isComplex = false,
        isStatic = false,
        isRelocatable = false,
        isLarge = false,
        isDummy = false,
        sizeOf = 0
    };
};

template <typename T>
class QTypeInfo<T*>
{
public:
    enum {
        isSpecialized = true,
        isPointer = true,
        isIntegral = false,
        isComplex = false,
        isStatic = false,
        isRelocatable = true,
        isLarge = false,
        isDummy = false,
        sizeOf = sizeof(T*)
    };
};
















template <typename T, typename = void>
struct QTypeInfoQuery : public QTypeInfo<T>
{
    enum { isRelocatable = !QTypeInfo<T>::isStatic };
};


template <typename T>
struct QTypeInfoQuery<T, typename std::enable_if<QTypeInfo<T>::isRelocatable || true>::type> : public QTypeInfo<T>
{};





















template <class T, class T1, class T2 = T1, class T3 = T1, class T4 = T1>
class QTypeInfoMerger
{
public:
    enum {
        isSpecialized = true,
        isComplex = QTypeInfoQuery<T1>::isComplex || QTypeInfoQuery<T2>::isComplex
                    || QTypeInfoQuery<T3>::isComplex || QTypeInfoQuery<T4>::isComplex,
        isStatic = QTypeInfoQuery<T1>::isStatic || QTypeInfoQuery<T2>::isStatic
                    || QTypeInfoQuery<T3>::isStatic || QTypeInfoQuery<T4>::isStatic,
        isRelocatable = QTypeInfoQuery<T1>::isRelocatable && QTypeInfoQuery<T2>::isRelocatable
                    && QTypeInfoQuery<T3>::isRelocatable && QTypeInfoQuery<T4>::isRelocatable,
        isLarge = sizeof(T) > sizeof(void*),
        isPointer = false,
        isIntegral = false,
        isDummy = false,
        sizeOf = sizeof(T)
    };
};




















template <typename T> class QList; template <typename T> class QTypeInfo< QList<T> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isRelocatable = true, isStatic = false, isLarge = (sizeof(QList<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QList<T>) }; };
template <typename T> class QVector; template <typename T> class QTypeInfo< QVector<T> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isRelocatable = true, isStatic = false, isLarge = (sizeof(QVector<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QVector<T>) }; };
template <typename T> class QQueue; template <typename T> class QTypeInfo< QQueue<T> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isRelocatable = true, isStatic = false, isLarge = (sizeof(QQueue<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QQueue<T>) }; };
template <typename T> class QStack; template <typename T> class QTypeInfo< QStack<T> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isRelocatable = true, isStatic = false, isLarge = (sizeof(QStack<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QStack<T>) }; };
template <typename T> class QSet; template <typename T> class QTypeInfo< QSet<T> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isRelocatable = true, isStatic = false, isLarge = (sizeof(QSet<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QSet<T>) }; };























template <typename K, typename V> class QMap; template <typename K, typename V> class QTypeInfo< QMap<K, V> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(15<<8)|(11)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QMap<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QMap<K, V>) }; };
template <typename K, typename V> class QMultiMap; template <typename K, typename V> class QTypeInfo< QMultiMap<K, V> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(15<<8)|(11)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QMultiMap<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QMultiMap<K, V>) }; };
template <typename K, typename V> class QHash; template <typename K, typename V> class QTypeInfo< QHash<K, V> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(15<<8)|(11)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QHash<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QHash<K, V>) }; };
template <typename K, typename V> class QMultiHash; template <typename K, typename V> class QTypeInfo< QMultiHash<K, V> > { public: enum { isSpecialized = true, isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(15<<8)|(11)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QMultiHash<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QMultiHash<K, V>) }; };











enum { 
    Q_COMPLEX_TYPE = 0,
    Q_PRIMITIVE_TYPE = 0x1,
    Q_STATIC_TYPE = 0,
    Q_MOVABLE_TYPE = 0x2,               
    Q_DUMMY_TYPE = 0x4,
    Q_RELOCATABLE_TYPE = 0x8
};
























template<typename T> class QFlags;
template<typename T>
class QTypeInfo<QFlags<T> > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QFlags<T>>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QFlags<T>>(), isLarge = (sizeof(QFlags<T>)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QFlags<T> >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QFlags<T>) }; static inline const char *name() { return "QFlags<T>"; } };





























template<> class QTypeInfo<bool > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<bool>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<bool>(), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< bool >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(bool) }; static inline const char *name() { return "bool"; } };
template<> class QTypeInfo<char > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<char>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<char>(), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< char >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(char) }; static inline const char *name() { return "char"; } };
template<> class QTypeInfo<signed char > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<signed char>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<signed char>(), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< signed char >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(signed char) }; static inline const char *name() { return "signed char"; } };
template<> class QTypeInfo<uchar > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<uchar>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<uchar>(), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< uchar >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(uchar) }; static inline const char *name() { return "uchar"; } };
template<> class QTypeInfo<short > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<short>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<short>(), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< short >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(short) }; static inline const char *name() { return "short"; } };
template<> class QTypeInfo<ushort > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<ushort>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<ushort>(), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< ushort >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(ushort) }; static inline const char *name() { return "ushort"; } };
template<> class QTypeInfo<int > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<int>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<int>(), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< int >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(int) }; static inline const char *name() { return "int"; } };
template<> class QTypeInfo<uint > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<uint>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<uint>(), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< uint >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(uint) }; static inline const char *name() { return "uint"; } };
template<> class QTypeInfo<long > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<long>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<long>(), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< long >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(long) }; static inline const char *name() { return "long"; } };
template<> class QTypeInfo<ulong > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<ulong>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<ulong>(), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< ulong >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(ulong) }; static inline const char *name() { return "ulong"; } };
template<> class QTypeInfo<qint64 > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<qint64>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<qint64>(), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< qint64 >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(qint64) }; static inline const char *name() { return "qint64"; } };
template<> class QTypeInfo<quint64 > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<quint64>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<quint64>(), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< quint64 >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(quint64) }; static inline const char *name() { return "quint64"; } };
template<> class QTypeInfo<float > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<float>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<float>(), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< float >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(float) }; static inline const char *name() { return "float"; } };
template<> class QTypeInfo<double > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<double>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<double>(), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< double >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(double) }; static inline const char *name() { return "double"; } };












#line 346 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"

template<> class QTypeInfo<long double > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<long double>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<long double>(), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< long double >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(long double) }; static inline const char *name() { return "long double"; } };


#line 351 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"

template<> class QTypeInfo<char16_t > { public: enum { isSpecialized = true, isComplex = (((Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<char16_t>(), isStatic = (((Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<char16_t>(), isLarge = (sizeof(char16_t)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< char16_t >::value, isDummy = (((Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(char16_t) }; static inline const char *name() { return "char16_t"; } };
template<> class QTypeInfo<char32_t > { public: enum { isSpecialized = true, isComplex = (((Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<char32_t>(), isStatic = (((Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<char32_t>(), isLarge = (sizeof(char32_t)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< char32_t >::value, isDummy = (((Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(char32_t) }; static inline const char *name() { return "char32_t"; } };
#line 355 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"

template<> class QTypeInfo<wchar_t > { public: enum { isSpecialized = true, isComplex = (((Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<wchar_t>(), isStatic = (((Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<wchar_t>(), isLarge = (sizeof(wchar_t)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< wchar_t >::value, isDummy = (((Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(wchar_t) }; static inline const char *name() { return "wchar_t"; } };
#line 358 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"
#line 359 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"


#line 362 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"
#pragma external_header(pop)
#line 1302 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"

























#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"

class QString;
class __declspec(dllimport) QSysInfo {
public:
    enum Sizes {
        WordSize = (sizeof(void *)<<3)
    };








#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"
    enum Endian {
        BigEndian,
        LittleEndian





#line 93 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"
        , ByteOrder = LittleEndian


#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"
    };
#line 99 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"



































































































































#line 231 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"

    static QString buildCpuArchitecture();
    static QString currentCpuArchitecture();
    static QString buildAbi();

    static QString kernelType();
    static QString kernelVersion();
    static QString productType();
    static QString productVersion();
    static QString prettyProductName();

    static QString machineHostName();
    static QByteArray machineUniqueId();
    static QByteArray bootUniqueId();
};




#line 251 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsysinfo.h"
#pragma external_header(pop)
#line 1303 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"







































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"







#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"








class QDebug;
class QNoDebug;

enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtInfoMsg, QtSystemMsg = QtCriticalMsg };

class QMessageLogContext
{
    QMessageLogContext(const QMessageLogContext &) = delete; QMessageLogContext &operator=(const QMessageLogContext &) = delete;
public:
    constexpr QMessageLogContext() noexcept = default;
    constexpr QMessageLogContext(const char *fileName, int lineNumber, const char *functionName, const char *categoryName) noexcept
        : line(lineNumber), file(fileName), function(functionName), category(categoryName) {}

    int version = 2;
    int line = 0;
    const char *file = nullptr;
    const char *function = nullptr;
    const char *category = nullptr;

private:
    QMessageLogContext &copyContextFrom(const QMessageLogContext &logContext) noexcept;

    friend class QMessageLogger;
    friend class QDebug;
};

class QLoggingCategory;

class __declspec(dllimport) QMessageLogger
{
    QMessageLogger(const QMessageLogger &) = delete; QMessageLogger &operator=(const QMessageLogger &) = delete;
public:
    constexpr QMessageLogger() : context() {}
    constexpr QMessageLogger(const char *file, int line, const char *function)
        : context(file, line, function, "default") {}
    constexpr QMessageLogger(const char *file, int line, const char *function, const char *category)
        : context(file, line, function, category) {}

    void debug(const char *msg, ...) const ;
    void noDebug(const char *, ...) const 
    {}
    void info(const char *msg, ...) const ;
    
    void warning(const char *msg, ...) const ;
    
    void critical(const char *msg, ...) const ;

    typedef const QLoggingCategory &(*CategoryFunction)();

    void debug(const QLoggingCategory &cat, const char *msg, ...) const ;
    void debug(CategoryFunction catFunc, const char *msg, ...) const ;
    void info(const QLoggingCategory &cat, const char *msg, ...) const ;
    void info(CategoryFunction catFunc, const char *msg, ...) const ;
    
    void warning(const QLoggingCategory &cat, const char *msg, ...) const ;
    
    void warning(CategoryFunction catFunc, const char *msg, ...) const ;
    
    void critical(const QLoggingCategory &cat, const char *msg, ...) const ;
    
    void critical(CategoryFunction catFunc, const char *msg, ...) const ;




    
    void fatal(const char *msg, ...) const noexcept ;


    QDebug debug() const;
    QDebug debug(const QLoggingCategory &cat) const;
    QDebug debug(CategoryFunction catFunc) const;
    QDebug info() const;
    QDebug info(const QLoggingCategory &cat) const;
    QDebug info(CategoryFunction catFunc) const;
    QDebug warning() const;
    QDebug warning(const QLoggingCategory &cat) const;
    QDebug warning(CategoryFunction catFunc) const;
    QDebug critical() const;
    QDebug critical(const QLoggingCategory &cat) const;
    QDebug critical(CategoryFunction catFunc) const;

    QNoDebug noDebug() const noexcept;
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"

private:
    QMessageLogContext context;
};




#line 150 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"

#line 152 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"
#line 153 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"


  
  
  




#line 163 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"












#line 176 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"



#line 180 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"



#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"

__declspec(dllimport) void qt_message_output(QtMsgType, const QMessageLogContext &context,
                                     const QString &message);

__declspec(dllimport)  void qErrnoWarning(int code, const char *msg, ...);
__declspec(dllimport)  void qErrnoWarning(const char *msg, ...);




#line 195 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"

typedef void (*QtMessageHandler)(QtMsgType, const QMessageLogContext &, const QString &);
__declspec(dllimport) QtMessageHandler qInstallMessageHandler(QtMessageHandler);

__declspec(dllimport) void qSetMessagePattern(const QString &messagePattern);
__declspec(dllimport) QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context,
                                        const QString &buf);


#line 205 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlogging.h"
#pragma external_header(pop)
#line 1304 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"







































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"








class QDataStream;

class QFlag
{
    int i;
public:
    constexpr inline QFlag(int value) noexcept : i(value) {}
    constexpr inline operator int() const noexcept { return i; }













#line 71 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"
};
template<> class QTypeInfo<QFlag > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QFlag>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QFlag>(), isLarge = (sizeof(QFlag)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QFlag >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QFlag) }; static inline const char *name() { return "QFlag"; } };

class QIncompatibleFlag
{
    int i;
public:
    constexpr inline explicit QIncompatibleFlag(int i) noexcept;
    constexpr inline operator int() const noexcept { return i; }
};
template<> class QTypeInfo<QIncompatibleFlag > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QIncompatibleFlag>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QIncompatibleFlag>(), isLarge = (sizeof(QIncompatibleFlag)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QIncompatibleFlag >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QIncompatibleFlag) }; static inline const char *name() { return "QIncompatibleFlag"; } };

constexpr inline QIncompatibleFlag::QIncompatibleFlag(int value) noexcept : i(value) {}




template<typename Enum>
class QFlags
{
    static_assert(bool((sizeof(Enum) <= sizeof(int))), "QFlags uses an int as storage, so an enum with underlying " "long long will overflow.");
#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"
    static_assert(bool((std::is_enum<Enum>::value)), "QFlags is only usable on enumeration types.");




#line 100 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"
    template <typename E> friend QDataStream &operator>>(QDataStream &, QFlags<E> &);
    template <typename E> friend QDataStream &operator<<(QDataStream &, QFlags<E>);
public:

    
    
    typedef int Int;






#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"
    typedef Enum enum_type;
    




    constexpr inline QFlags() noexcept : i(0) {}
    constexpr inline QFlags(Enum flags) noexcept : i(Int(flags)) {}


#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"
    constexpr inline QFlags(QFlag flag) noexcept : i(flag) {}

    constexpr inline QFlags(std::initializer_list<Enum> flags) noexcept
        : i(initializer_list_helper(flags.begin(), flags.end())) {}

    constexpr inline QFlags &operator&=(int mask) noexcept { i &= mask; return *this; }
    constexpr inline QFlags &operator&=(uint mask) noexcept { i &= mask; return *this; }
    constexpr inline QFlags &operator&=(Enum mask) noexcept { i &= Int(mask); return *this; }
    constexpr inline QFlags &operator|=(QFlags other) noexcept { i |= other.i; return *this; }
    constexpr inline QFlags &operator|=(Enum other) noexcept { i |= Int(other); return *this; }
    constexpr inline QFlags &operator^=(QFlags other) noexcept { i ^= other.i; return *this; }
    constexpr inline QFlags &operator^=(Enum other) noexcept { i ^= Int(other); return *this; }

    constexpr inline operator Int() const noexcept { return i; }

    constexpr inline QFlags operator|(QFlags other) const noexcept { return QFlags(QFlag(i | other.i)); }
    constexpr inline QFlags operator|(Enum other) const noexcept { return QFlags(QFlag(i | Int(other))); }
    constexpr inline QFlags operator^(QFlags other) const noexcept { return QFlags(QFlag(i ^ other.i)); }
    constexpr inline QFlags operator^(Enum other) const noexcept { return QFlags(QFlag(i ^ Int(other))); }
    constexpr inline QFlags operator&(int mask) const noexcept { return QFlags(QFlag(i & mask)); }
    constexpr inline QFlags operator&(uint mask) const noexcept { return QFlags(QFlag(i & mask)); }
    constexpr inline QFlags operator&(Enum other) const noexcept { return QFlags(QFlag(i & Int(other))); }
    constexpr inline QFlags operator~() const noexcept { return QFlags(QFlag(~i)); }

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

    constexpr inline bool testFlag(Enum flag) const noexcept { return (i & Int(flag)) == Int(flag) && (Int(flag) != 0 || i == Int(flag) ); }
    constexpr inline QFlags &setFlag(Enum flag, bool on = true) noexcept
    {
        return on ? (*this |= flag) : (*this &= ~Int(flag));
    }

private:
    constexpr static inline Int initializer_list_helper(typename std::initializer_list<Enum>::const_iterator it,
                                                               typename std::initializer_list<Enum>::const_iterator end)
    noexcept
    {
        return (it == end ? Int(0) : (Int(*it) | initializer_list_helper(it + 1, end)));
    }

    Int i;
};




#line 172 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"





















#line 194 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"




  









#line 209 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"















#line 225 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qflags.h"
#pragma external_header(pop)
#line 1306 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"




#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"










#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qgenericatomic.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qgenericatomic.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtypeinfo.h"
































































































































































































































































































































#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qgenericatomic.h"








#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qgenericatomic.h"

template<int> struct QAtomicOpsSupport { enum { IsSupported = 0 }; };
template<> struct QAtomicOpsSupport<4> { enum { IsSupported = 1 }; };

template <typename T> struct QAtomicAdditiveType
{
    typedef T AdditiveT;
    static const int AddScale = 1;
};
template <typename T> struct QAtomicAdditiveType<T *>
{
    typedef qptrdiff AdditiveT;
    static const int AddScale = sizeof(T);
};


template <typename BaseClass> struct QGenericAtomicOps
{
    template <typename T> struct AtomicType { typedef T Type; typedef T *PointerType; };

    template <typename T> static void acquireMemoryFence(const T &_q_value) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
    }
    template <typename T> static void releaseMemoryFence(const T &_q_value) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
    }
    template <typename T> static void orderedMemoryFence(const T &) noexcept
    {
    }

    template <typename T> static __forceinline
    T load(const T &_q_value) noexcept
    {
        return _q_value;
    }

    template <typename T, typename X> static __forceinline
    void store(T &_q_value, X newValue) noexcept
    {
        _q_value = newValue;
    }

    template <typename T> static __forceinline
    T loadRelaxed(const T &_q_value) noexcept
    {
        return _q_value;
    }

    template <typename T, typename X> static __forceinline
    void storeRelaxed(T &_q_value, X newValue) noexcept
    {
        _q_value = newValue;
    }

    template <typename T> static __forceinline
    T loadAcquire(const T &_q_value) noexcept
    {
        T tmp = *static_cast<const volatile T *>(&_q_value);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T, typename X> static __forceinline
    void storeRelease(T &_q_value, X newValue) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        *static_cast<volatile T *>(&_q_value) = newValue;
    }

    static inline constexpr bool isReferenceCountingNative() noexcept
    { return BaseClass::isFetchAndAddNative(); }
    static inline constexpr bool isReferenceCountingWaitFree() noexcept
    { return BaseClass::isFetchAndAddWaitFree(); }
    template <typename T> static __forceinline
    bool ref(T &_q_value) noexcept
    {
        return BaseClass::fetchAndAddRelaxed(_q_value, 1) != T(-1);
    }

    template <typename T> static __forceinline
    bool deref(T &_q_value) noexcept
    {
         return BaseClass::fetchAndAddRelaxed(_q_value, -1) != 1;
    }










#line 152 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qgenericatomic.h"

    template <typename T, typename X> static __forceinline
    bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue) noexcept
    {
        bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T, typename X> static __forceinline
    bool testAndSetRelease(T &_q_value, X expectedValue, X newValue) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
    }

    template <typename T, typename X> static __forceinline
    bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
    }

    template <typename T, typename X> static __forceinline
    bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept
    {
        bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T, typename X> static __forceinline
    bool testAndSetRelease(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue);
    }

    template <typename T, typename X> static __forceinline
    bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue);
    }

    static inline constexpr bool isFetchAndStoreNative() noexcept { return false; }
    static inline constexpr bool isFetchAndStoreWaitFree() noexcept { return false; }

    template <typename T, typename X> static __forceinline
    T fetchAndStoreRelaxed(T &_q_value, X newValue) noexcept
    {
        
        for(;;) {
            T tmp = loadRelaxed(_q_value);
            if (BaseClass::testAndSetRelaxed(_q_value, tmp, newValue))
                return tmp;
        }
    }

    template <typename T, typename X> static __forceinline
    T fetchAndStoreAcquire(T &_q_value, X newValue) noexcept
    {
        T tmp = BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T, typename X> static __forceinline
    T fetchAndStoreRelease(T &_q_value, X newValue) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
    }

    template <typename T, typename X> static __forceinline
    T fetchAndStoreOrdered(T &_q_value, X newValue) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
    }

    static inline constexpr bool isFetchAndAddNative() noexcept { return false; }
    static inline constexpr bool isFetchAndAddWaitFree() noexcept { return false; }
    template <typename T> static __forceinline
    T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        
        for(;;) {
            T tmp = BaseClass::loadRelaxed(_q_value);
            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp + valueToAdd)))
                return tmp;
        }
    }

    template <typename T> static __forceinline
    T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        T tmp = BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T> static __forceinline
    T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
    }

    template <typename T> static __forceinline
    T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
    }

__pragma(warning(push))
__pragma(warning(disable: 4146))   
    template <typename T> static __forceinline
    T fetchAndSubRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
    {
        
        return fetchAndAddRelaxed(_q_value, -operand);
    }
__pragma(warning(pop))

    template <typename T> static __forceinline
    T fetchAndSubAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
    {
        T tmp = BaseClass::fetchAndSubRelaxed(_q_value, operand);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T> static __forceinline
    T fetchAndSubRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::fetchAndSubRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndSubOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::fetchAndSubRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndAndRelaxed(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        
        T tmp = BaseClass::loadRelaxed(_q_value);
        for(;;) {
            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp & operand), &tmp))
                return tmp;
        }
    }

    template <typename T> static __forceinline
    T fetchAndAndAcquire(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        T tmp = BaseClass::fetchAndAndRelaxed(_q_value, operand);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T> static __forceinline
    T fetchAndAndRelease(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::fetchAndAndRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndAndOrdered(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::fetchAndAndRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndOrRelaxed(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        
        T tmp = BaseClass::loadRelaxed(_q_value);
        for(;;) {
            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp | operand), &tmp))
                return tmp;
        }
    }

    template <typename T> static __forceinline
    T fetchAndOrAcquire(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        T tmp = BaseClass::fetchAndOrRelaxed(_q_value, operand);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T> static __forceinline
    T fetchAndOrRelease(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::fetchAndOrRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndOrOrdered(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::fetchAndOrRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndXorRelaxed(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        
        T tmp = BaseClass::loadRelaxed(_q_value);
        for(;;) {
            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp ^ operand), &tmp))
                return tmp;
        }
    }

    template <typename T> static __forceinline
    T fetchAndXorAcquire(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        T tmp = BaseClass::fetchAndXorRelaxed(_q_value, operand);
        BaseClass::acquireMemoryFence(_q_value);
        return tmp;
    }

    template <typename T> static __forceinline
    T fetchAndXorRelease(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        BaseClass::releaseMemoryFence(_q_value);
        return BaseClass::fetchAndXorRelaxed(_q_value, operand);
    }

    template <typename T> static __forceinline
    T fetchAndXorOrdered(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
    {
        BaseClass::orderedMemoryFence(_q_value);
        return BaseClass::fetchAndXorRelaxed(_q_value, operand);
    }
};


#line 402 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qgenericatomic.h"
#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"





#pragma once














#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic_wait.h"
#line 73 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xatomic_wait.h"
#pragma external_header(pop)
#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 23 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.h"





#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtimec.h"





#pragma once





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"





#pragma once





#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {



#line 24 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"






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 51 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
__declspec(dllimport) 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."))
__declspec(dllimport) 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."))
__declspec(dllimport) 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."))
__declspec(dllimport) char** __cdecl __tzname(void);



  
__declspec(dllimport) errno_t __cdecl _get_daylight(
      int* _Daylight
    );

 
__declspec(dllimport) errno_t __cdecl _get_dstbias(
      long* _DaylightSavingsBias
    );

  
__declspec(dllimport) errno_t __cdecl _get_timezone(
      long* _TimeZone
    );

 
__declspec(dllimport) 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."))
__declspec(dllimport) char* __cdecl asctime(
      struct tm const* _Tm
    );


     
    
    __declspec(dllimport) errno_t __cdecl asctime_s(
            char*            _Buffer,
                                            size_t           _SizeInBytes,
                                                         struct tm const* _Tm
        );
#line 136 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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 142 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"

 
__declspec(dllimport) 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."))
__declspec(dllimport) char* __cdecl _ctime32(
      __time32_t const* _Time
    );


__declspec(dllimport) 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 165 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
__declspec(dllimport) char* __cdecl _ctime64(
      __time64_t const* _Time
    );


__declspec(dllimport) 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 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"

 
__declspec(dllimport) double __cdecl _difftime32(
      __time32_t _Time1,
      __time32_t _Time2
    );

 
__declspec(dllimport) 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."))
__declspec(dllimport) struct tm* __cdecl _gmtime32(
      __time32_t const* _Time
    );


__declspec(dllimport) 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."))
__declspec(dllimport) struct tm* __cdecl _gmtime64(
      __time64_t const* _Time
    );


__declspec(dllimport) 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."))
__declspec(dllimport) struct tm* __cdecl _localtime32(
      __time32_t const* _Time
    );


__declspec(dllimport) 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."))
__declspec(dllimport) struct tm* __cdecl _localtime64(
      __time64_t const* _Time
    );


__declspec(dllimport) errno_t __cdecl _localtime64_s(
      struct tm*        _Tm,
       __time64_t const* _Time
    );

 
__declspec(dllimport) __time32_t __cdecl _mkgmtime32(
      struct tm* _Tm
    );

 
__declspec(dllimport) __time64_t __cdecl _mkgmtime64(
      struct tm* _Tm
    );


__declspec(dllimport) __time32_t __cdecl _mktime32(
      struct tm* _Tm
    );


__declspec(dllimport) __time64_t __cdecl _mktime64(
      struct tm* _Tm
    );

 

__declspec(dllimport) size_t __cdecl strftime(
       char*            _Buffer,
                               size_t           _SizeInBytes,
        char const*      _Format,
                               struct tm const* _Tm
    );

 

__declspec(dllimport) size_t __cdecl _strftime_l(
           char*            _Buffer,
                               size_t           _MaxSize,
        char const*      _Format,
                               struct tm const* _Tm,
                           _locale_t        _Locale
    );


__declspec(dllimport) 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 295 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.")) __declspec(dllimport)  char* __cdecl _strdate( char *_Buffer);
#line 300 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"


__declspec(dllimport) 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 311 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.")) __declspec(dllimport) char* __cdecl _strtime( char *_Buffer);
#line 316 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"

__declspec(dllimport) __time32_t __cdecl _time32(
      __time32_t* _Time
    );

__declspec(dllimport) __time64_t __cdecl _time64(
      __time64_t* _Time
    );

 
 
__declspec(dllimport) int __cdecl _timespec32_get(
      struct _timespec32* _Ts,
       int                 _Base
    );

 
 
__declspec(dllimport) int __cdecl _timespec64_get(
      struct _timespec64* _Ts,
       int                 _Base
    );










    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) unsigned __cdecl _setsystime(
          struct tm* _Tm,
          unsigned   _Milliseconds
        );

#line 363 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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);
            }

        

























#line 602 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"
            
            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 620 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"
        #line 621 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"

    #line 623 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"

#line 625 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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.")) __declspec(dllimport) void __cdecl tzset(void);
    #line 640 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"

#line 642 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 649 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\time.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 :: strftime;

 using :: timespec;
#line 32 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"













































#line 78 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"


 using :: ctime;
 using :: difftime;
 using :: gmtime;
 using :: localtime;
 using :: mktime;
 using :: time;

 using :: timespec_get;
#line 89 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"

#line 91 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"
}



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

#line 99 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"
#line 100 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ctime"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtimec.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    )




extern "C" {

 long __cdecl _Xtime_diff_to_millis2(const _timespec64*, const _timespec64*);
 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 41 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtimec.h"
#line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtimec.h"
















#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.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    )




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      = 80;
inline constexpr size_t _Mtx_internal_imp_alignment = 8;
inline constexpr size_t _Cnd_internal_imp_size      = 72;
inline constexpr size_t _Cnd_internal_imp_alignment = 8;





#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.h"
#line 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.h"





struct _Mtx_internal_imp_t;
struct _Cnd_internal_imp_t;
using _Mtx_t = _Mtx_internal_imp_t*;
using _Cnd_t = _Cnd_internal_imp_t*;
#line 64 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.h"

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 _timespec64*);
 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 _timespec64*);
 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 _timespec64*);
 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
};

extern "C++" [[noreturn]]  void __cdecl _Throw_Cpp_error(int _Code);
}


#pragma warning(pop)
#pragma pack(pop)
#line 139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.h"
#line 140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xthreads.h"
















#pragma external_header(pop)
#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 36 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"





extern "C" [[nodiscard]] unsigned char __stdcall __std_atomic_compare_exchange_128(
      long long* _Destination,   long long _ExchangeHigh,   long long _ExchangeLow,
      long long* _ComparandResult) noexcept;
extern "C" [[nodiscard]] char __stdcall __std_atomic_has_cmpxchg16b() noexcept;

#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"




#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

#line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"









#line 65 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

#line 67 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 68 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"





#line 74 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"













enum {
    _Atomic_memory_order_relaxed,
    _Atomic_memory_order_consume,
    _Atomic_memory_order_acquire,
    _Atomic_memory_order_release,
    _Atomic_memory_order_acq_rel,
    _Atomic_memory_order_seq_cst,
};






#line 102 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 103 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

extern "C" inline void _Check_memory_order(const unsigned int _Order) noexcept {
    if (_Order > _Atomic_memory_order_seq_cst) {
        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 106, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 106, 0); } while (false);
    }
}






























#line 140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

























#line 166 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
























#line 191 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"





#line 197 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"


























#line 224 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

#line 226 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"














#line 241 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"



#line 245 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"






#line 252 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"


#line 255 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

#pragma warning(push)
#pragma warning(disable : 6001) 
#pragma warning(disable : 28113) 
                                 
extern "C" inline void _Atomic_thread_fence(const unsigned int _Order) noexcept {
    if (_Order == _Atomic_memory_order_relaxed) {
        return;
    }


    __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
    if (_Order == _Atomic_memory_order_seq_cst) {
        volatile long _Guard; 

        
        
        
        (void) _InterlockedIncrement(&_Guard);
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
    }




#line 281 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
}
#pragma warning(pop)



extern "C" {
_Smtx_t* __stdcall __std_atomic_get_mutex(const void* _Key) noexcept;
}







#line 297 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

namespace std {

struct _Form_mask_t {};
inline constexpr _Form_mask_t _Form_mask{};
#line 303 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 334 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

 extern "C" inline void atomic_thread_fence(const memory_order _Order) noexcept {
    ::_Atomic_thread_fence(static_cast<unsigned int>(_Order));
}

 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_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:
        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 361, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 361, 0); } while (false);
        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:
        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 377, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 377, 0); } while (false);
        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(static_cast<unsigned int>(_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;
    }
}


template <class _Ty>
struct _Atomic_padded {
    alignas(sizeof(_Ty)) mutable _Ty _Value; 
};







































#line 474 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 492 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 514 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

            return;
        }

        __std_atomic_wait_direct(_Storage_ptr, &_Expected_bytes, sizeof(_Value_type), _Atomic_wait_no_timeout);
    }
}
#line 522 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"


inline void _Atomic_lock_acquire(long& _Spinlock) noexcept {

    
    
    
    int _Current_backoff       = 1;
    constexpr 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 548 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
}

inline void _Atomic_lock_release(long& _Spinlock) noexcept {

    _InterlockedExchange(&_Spinlock, 0); 






#line 560 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}


inline bool __stdcall _Atomic_wait_compare_16_bytes(const void* _Storage, void* _Comparand, size_t, void*) noexcept {
    const auto _Dest              = static_cast<long long*>(const_cast<void*>(_Storage));
    const auto _Cmp               = static_cast<const long long*>(_Comparand);
    alignas(16) long long _Tmp[2] = {_Cmp[0], _Cmp[1]};

    return __std_atomic_compare_exchange_128(_Dest, _Tmp[1], _Tmp[0], _Tmp) != 0;


#line 609 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
}
#line 611 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 612 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 613 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_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(static_cast<unsigned int>(_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 662 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 676 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 711 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 730 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 748 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
        (void) _InterlockedExchange8(((_Mem)), ((_As_bytes)));
    }

    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 (static_cast<unsigned int>(_Order)) {
            case _Atomic_memory_order_relaxed: __iso_volatile_store8((_Mem), (_As_bytes)); return; case _Atomic_memory_order_release: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); __iso_volatile_store8((_Mem), (_As_bytes)); return; default: case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_acq_rel: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 772, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 772, 0); } while (false); [[fallthrough]];
        case _Atomic_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;


#line 792 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _As_bytes = __iso_volatile_load8(_Mem);
        switch (static_cast<unsigned int>(_Order)) { case _Atomic_memory_order_relaxed: break; case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_seq_cst: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); break; case _Atomic_memory_order_release: case _Atomic_memory_order_acq_rel: default: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 793, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 793, 0); } while (false); break; }
#line 795 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        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(static_cast<unsigned int>(_Order)); _As_bytes = _InterlockedExchange8(_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Value));
#line 803 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange8(_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Desired), _Expected_bytes);
#line 819 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 831 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange8(_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Desired), _Expected_bytes);
#line 833 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 854 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
        (void) _InterlockedExchange16(((_Mem)), ((_As_bytes)));
    }

    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 (static_cast<unsigned int>(_Order)) {
            case _Atomic_memory_order_relaxed: __iso_volatile_store16((_Mem), (_As_bytes)); return; case _Atomic_memory_order_release: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); __iso_volatile_store16((_Mem), (_As_bytes)); return; default: case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_acq_rel: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 880, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 880, 0); } while (false); [[fallthrough]];
        case _Atomic_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;


#line 900 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _As_bytes = __iso_volatile_load16(_Mem);
        switch (static_cast<unsigned int>(_Order)) { case _Atomic_memory_order_relaxed: break; case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_seq_cst: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); break; case _Atomic_memory_order_release: case _Atomic_memory_order_acq_rel: default: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 901, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 901, 0); } while (false); break; }
#line 903 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        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(static_cast<unsigned int>(_Order)); _As_bytes = _InterlockedExchange16(_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Value));
#line 911 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange16(_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Desired), _Expected_bytes);
#line 926 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 938 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange16(_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Desired), _Expected_bytes);
#line 940 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 961 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { 
        const auto _Mem     = _Atomic_address_as<int>(_Storage);
        const int _As_bytes = _Atomic_reinterpret_as<int>(_Value);
        (void) _InterlockedExchange(reinterpret_cast<volatile long*>((_Mem)), static_cast<long>((_As_bytes)));
    }

    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 (static_cast<unsigned int>(_Order)) {
            case _Atomic_memory_order_relaxed: __iso_volatile_store32((_Mem), (_As_bytes)); return; case _Atomic_memory_order_release: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); __iso_volatile_store32((_Mem), (_As_bytes)); return; default: case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_acq_rel: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 987, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 987, 0); } while (false); [[fallthrough]];
        case _Atomic_memory_order_seq_cst:
            store(_Value);
            return;
        }
    }

    [[nodiscard]] _TVal load() const noexcept { 
        const auto _Mem = _Atomic_address_as<int>(_Storage);
        int _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);
        int _As_bytes;


#line 1007 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _As_bytes = __iso_volatile_load32(_Mem);
        switch (static_cast<unsigned int>(_Order)) { case _Atomic_memory_order_relaxed: break; case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_seq_cst: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); break; case _Atomic_memory_order_release: case _Atomic_memory_order_acq_rel: default: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 1008, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 1008, 0); } while (false); break; }
#line 1010 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        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(static_cast<unsigned int>(_Order)); _As_bytes = _InterlockedExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Value));
#line 1018 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Desired), _Expected_bytes);
#line 1033 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1045 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Desired), _Expected_bytes);
#line 1047 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1068 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
        (void) _InterlockedExchange64(((_Mem)), ((_As_bytes)));;
    }

    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 (static_cast<unsigned int>(_Order)) {
            case _Atomic_memory_order_relaxed: __iso_volatile_store64((_Mem), (_As_bytes)); return; case _Atomic_memory_order_release: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); __iso_volatile_store64((_Mem), (_As_bytes)); return; default: case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_acq_rel: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 1094, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 1094, 0); } while (false); [[fallthrough]];
        case _Atomic_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 = __iso_volatile_load64(_Mem);
#line 1108 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        __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<long long>(_Storage);
        long long _As_bytes;


#line 1118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"




        _As_bytes = __iso_volatile_load64(_Mem);
#line 1124 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

        switch (static_cast<unsigned int>(_Order)) { case _Atomic_memory_order_relaxed: break; case _Atomic_memory_order_consume: case _Atomic_memory_order_acquire: case _Atomic_memory_order_seq_cst: __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop)); break; case _Atomic_memory_order_release: case _Atomic_memory_order_acq_rel: default: do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 1125, 0, "%s", "Invalid memory order")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid memory order\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 1125, 0); } while (false); break; }
#line 1127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        return reinterpret_cast<_TVal&>(_As_bytes);
    }











    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        long long _As_bytes;
        _Check_memory_order(static_cast<unsigned int>(_Order)); _As_bytes = _InterlockedExchange64(_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Value));
#line 1145 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        return reinterpret_cast<_TVal&>(_As_bytes);
    }
#line 1148 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange64(_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Desired), _Expected_bytes);
#line 1163 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1175 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Prev_bytes = _InterlockedCompareExchange64(_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Desired), _Expected_bytes);
#line 1177 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1198 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
};


template <class _Ty>
struct _Atomic_storage<_Ty&, 16> { 
    
    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 { 
        (void) exchange(_Value);
    }

    void store(const _TVal _Value, const memory_order _Order) noexcept { 
        _Check_store_memory_order(_Order);
        (void) exchange(_Value, _Order);
    }

    [[nodiscard]] _TVal load() const noexcept { 
        long long* const _Storage_ptr = const_cast<long long*>(_Atomic_address_as<const long long>(_Storage));
        _Int128 _Result{}; 
        (void) __std_atomic_compare_exchange_128(_Storage_ptr, 0, 0, &_Result._Low);
        return reinterpret_cast<_TVal&>(_Result);
    }

    [[nodiscard]] _TVal load(const memory_order _Order) const noexcept { 






















#line 1253 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_load_memory_order(_Order);
        return load();
#line 1256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
    }

    _TVal exchange(const _TVal _Value) noexcept { 
        _TVal _Result{_Value};
        while (!compare_exchange_strong(_Result, _Value)) { 
        }

        return _Result;
    }

    _TVal exchange(const _TVal _Value, const memory_order _Order) noexcept { 
        _TVal _Result{_Value};
        while (!compare_exchange_strong(_Result, _Value, _Order)) { 
        }

        return _Result;
    }

    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept { 
        _Int128 _Desired_bytes{};
        :: memcpy(&_Desired_bytes, ::std:: addressof(_Desired), sizeof(_TVal));
        _Int128 _Expected_temp{};
        :: memcpy(&_Expected_temp, ::std:: addressof(_Expected), sizeof(_TVal));
        unsigned char _Result;

        if constexpr (_Might_have_non_value_bits<_TVal>) {
            _Int128 _Expected_originally{};
            :: memcpy(&_Expected_originally, ::std:: addressof(_Expected), sizeof(_TVal));

            _Storage_for<_TVal> _Mask{_Form_mask};
            _Int128 _Mask_val{};
            :: memcpy(&_Mask_val, _Mask._Ptr(), sizeof(_TVal));
            for (;;) {




#line 1295 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
                (void) _Order;
                _Result = __std_atomic_compare_exchange_128(&reinterpret_cast<long long&>(_Storage), _Desired_bytes._High,
                    _Desired_bytes._Low, &_Expected_temp._Low);
#line 1299 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
                if (_Result) {
                    return true;
                }

                if (((_Expected_temp._Low ^ _Expected_originally._Low) & _Mask_val._Low) != 0
                    || ((_Expected_temp._High ^ _Expected_originally._High) & _Mask_val._High) != 0) {
                    :: memcpy(::std:: addressof(_Expected), &_Expected_temp, sizeof(_TVal));
                    return false;
                }

                _Expected_temp._Low =
                    (_Expected_originally._Low & _Mask_val._Low) | (_Expected_temp._Low & ~_Mask_val._Low);
                _Expected_temp._High =
                    (_Expected_originally._High & _Mask_val._High) | (_Expected_temp._High & ~_Mask_val._High);
            }
        }
#line 1316 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"



#line 1320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        (void) _Order;
        _Result = __std_atomic_compare_exchange_128(
            &reinterpret_cast<long long&>(_Storage), _Desired_bytes._High, _Desired_bytes._Low, &_Expected_temp._Low);
#line 1324 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        if (_Result == 0) {
            :: memcpy(::std:: addressof(_Expected), &_Expected_temp, sizeof(_TVal));
        }

        return _Result != 0;
    }


    void wait(_TVal _Expected, memory_order _Order = memory_order_seq_cst) const noexcept {
        const auto _Storage_ptr  = ::std:: addressof(_Storage);
        const auto _Expected_ptr = ::std:: addressof(_Expected);
        _Int128 _Expected_bytes  = reinterpret_cast<const _Int128&>(_Expected);

        for (;;) {
            const _TVal _Observed   = load(_Order);
            _Int128 _Observed_bytes = reinterpret_cast<const _Int128&>(_Observed);
            if (_Observed_bytes._Low != _Expected_bytes._Low || _Observed_bytes._High != _Expected_bytes._High) {

                if constexpr (_Might_have_non_value_bits<_TVal>) {
                    _Storage_for<_TVal> _Mask{_Form_mask};
                    const _Int128 _Mask_val = reinterpret_cast<const _Int128&>(_Mask._Ref());

                    if (((_Expected_bytes._Low ^ _Observed_bytes._Low) & _Mask_val._Low) == 0
                        && ((_Expected_bytes._High ^ _Observed_bytes._High) & _Mask_val._High) == 0) {
                        _Expected_bytes = _Observed_bytes;
                        continue;
                    }
                }
#line 1353 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

                return;
            }

            __std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), nullptr,
                &_Atomic_wait_compare_16_bytes, _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 1370 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

    struct _Int128 {
        alignas(16) long long _Low;
        long long _High;
    };

    typename _Atomic_storage_types<_Ty&>::_TStorage _Storage;
};
#line 1379 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

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(static_cast<unsigned int>(_Order)); _Result = _InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1394 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedAnd8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1401 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedOr8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1408 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedXor8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1415 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedExchangeAdd16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1452 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedAnd16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1459 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedOr16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1466 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedXor16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1473 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedExchangeAdd(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1510 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedAnd(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1517 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedOr(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1524 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<unsigned int>(_Order)); _Result = _InterlockedXor(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1531 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
        long long _Result;
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Result = _InterlockedExchangeAdd64(_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
#line 1622 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long long _Result;
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Result = _InterlockedAnd64(_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
#line 1629 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long long _Result;
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Result = _InterlockedOr64(_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
#line 1636 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long long _Result;
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Result = _InterlockedXor64(_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
#line 1643 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal operator++(int) noexcept {
        unsigned long long _After =
            static_cast<unsigned long long>(_InterlockedIncrement64(_Atomic_address_as<long long>(this->_Storage)));
        --_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator++() noexcept {
        return static_cast<_TVal>(_InterlockedIncrement64(_Atomic_address_as<long long>(this->_Storage)));
    }

    _TVal operator--(int) noexcept {
        unsigned long long _After =
            static_cast<unsigned long long>(_InterlockedDecrement64(_Atomic_address_as<long long>(this->_Storage)));
        ++_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator--() noexcept {
        return static_cast<_TVal>(_InterlockedDecrement64(_Atomic_address_as<long long>(this->_Storage)));
    }
#line 1668 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
};


template <size_t _TypeSize>
inline constexpr bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;








#line 1682 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress 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 1996 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;



#line 2012 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Result = _InterlockedExchangeAdd64(_Atomic_address_as<long long>(this->_Storage), _Shift_bytes);
#line 2014 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 2015 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;



#line 2108 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        _Check_memory_order(static_cast<unsigned int>(_Order)); _Result = _InterlockedExchangeAdd64(_Atomic_address_as<long long>(this->_Storage), _Shift_bytes);
#line 2110 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 2111 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2164 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"


    [[nodiscard]] bool is_lock_free() const volatile noexcept {
        constexpr bool _Result = sizeof(_Ty) <= 8 && (sizeof(_Ty) & sizeof(_Ty) - 1) == 0;
        return _Result;
    }










#line 2205 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2327 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2342 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {


#line 2377 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
        if constexpr (is_always_lock_free) {
            return true;
        } else {
            return __std_atomic_has_cmpxchg16b() != 0;
        }
#line 2383 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        do { if ((reinterpret_cast<uintptr_t>(::std:: addressof(_Value)) & (required_alignment - 1)) == 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 2448, 0, "%s", "atomic_ref underlying object is not aligned as required_alignment")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"atomic_ref underlying object is not aligned as required_alignment\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic", 2448, 0); } while (false); } ; } while (false);
#line 2449 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
    }
};
#line 2452 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress 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 suppress 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 2760 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2778 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2822 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2836 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2880 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"


    atomic<long> _Storage;


#line 2886 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2907 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3041 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"

}

























#pragma warning(pop)
#pragma pack(pop)
#line 3071 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#line 3072 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\atomic"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"








#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"




















template <int N> struct QAtomicTraits
{ static constexpr inline bool isLockFree(); };












template <> constexpr inline bool QAtomicTraits<4>::isLockFree()
{ return true; }
























#line 116 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"
















#line 133 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"

template<> struct QAtomicOpsSupport<1> { enum { IsSupported = 1 }; };







template <> constexpr inline bool QAtomicTraits<1>::isLockFree()
{ return true; }
















#line 161 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"

template<> struct QAtomicOpsSupport<2> { enum { IsSupported = 1 }; };







template <> constexpr inline bool QAtomicTraits<2>::isLockFree()
{ return false; }
















#line 189 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"


template<> struct QAtomicOpsSupport<8> { enum { IsSupported = 1 }; };







template <> constexpr inline bool QAtomicTraits<8>::isLockFree()
{ return true; }
















#line 218 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"
#line 219 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"

template <typename X> struct QAtomicOps
{
    typedef std::atomic<X> Type;

    template <typename T> static inline
    T load(const std::atomic<T> &_q_value) noexcept
    {
        return _q_value.load(std::memory_order_relaxed);
    }

    template <typename T> static inline
    T load(const volatile std::atomic<T> &_q_value) noexcept
    {
        return _q_value.load(std::memory_order_relaxed);
    }

    template <typename T> static inline
    T loadRelaxed(const std::atomic<T> &_q_value) noexcept
    {
        return _q_value.load(std::memory_order_relaxed);
    }

    template <typename T> static inline
    T loadRelaxed(const volatile std::atomic<T> &_q_value) noexcept
    {
        return _q_value.load(std::memory_order_relaxed);
    }

    template <typename T> static inline
    T loadAcquire(const std::atomic<T> &_q_value) noexcept
    {
        return _q_value.load(std::memory_order_acquire);
    }

    template <typename T> static inline
    T loadAcquire(const volatile std::atomic<T> &_q_value) noexcept
    {
        return _q_value.load(std::memory_order_acquire);
    }

    template <typename T> static inline
    void store(std::atomic<T> &_q_value, T newValue) noexcept
    {
        _q_value.store(newValue, std::memory_order_relaxed);
    }

    template <typename T> static inline
    void storeRelaxed(std::atomic<T> &_q_value, T newValue) noexcept
    {
        _q_value.store(newValue, std::memory_order_relaxed);
    }

    template <typename T> static inline
    void storeRelease(std::atomic<T> &_q_value, T newValue) noexcept
    {
        _q_value.store(newValue, std::memory_order_release);
    }

    static inline constexpr bool isReferenceCountingNative() noexcept { return isTestAndSetNative(); }
    static inline constexpr bool isReferenceCountingWaitFree() noexcept { return false; }
    template <typename T>
    static inline bool ref(std::atomic<T> &_q_value)
    {
        return ++_q_value != 0;
    }

    template <typename T>
    static inline bool deref(std::atomic<T> &_q_value) noexcept
    {
        return --_q_value != 0;
    }

    static inline constexpr bool isTestAndSetNative() noexcept
    { return QAtomicTraits<sizeof(X)>::isLockFree(); }
    static inline constexpr bool isTestAndSetWaitFree() noexcept { return false; }

    template <typename T>
    static bool testAndSetRelaxed(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
    {
        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_relaxed, std::memory_order_relaxed);
        if (currentValue)
            *currentValue = expectedValue;
        return tmp;
    }

    template <typename T>
    static bool testAndSetAcquire(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
    {
        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acquire, std::memory_order_acquire);
        if (currentValue)
            *currentValue = expectedValue;
        return tmp;
    }

    template <typename T>
    static bool testAndSetRelease(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
    {
        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_release, std::memory_order_relaxed);
        if (currentValue)
            *currentValue = expectedValue;
        return tmp;
    }

    template <typename T>
    static bool testAndSetOrdered(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
    {
        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acq_rel, std::memory_order_acquire);
        if (currentValue)
            *currentValue = expectedValue;
        return tmp;
    }

    static inline constexpr bool isFetchAndStoreNative() noexcept { return isTestAndSetNative(); }
    static inline constexpr bool isFetchAndStoreWaitFree() noexcept { return false; }

    template <typename T>
    static T fetchAndStoreRelaxed(std::atomic<T> &_q_value, T newValue) noexcept
    {
        return _q_value.exchange(newValue, std::memory_order_relaxed);
    }

    template <typename T>
    static T fetchAndStoreAcquire(std::atomic<T> &_q_value, T newValue) noexcept
    {
        return _q_value.exchange(newValue, std::memory_order_acquire);
    }

    template <typename T>
    static T fetchAndStoreRelease(std::atomic<T> &_q_value, T newValue) noexcept
    {
        return _q_value.exchange(newValue, std::memory_order_release);
    }

    template <typename T>
    static T fetchAndStoreOrdered(std::atomic<T> &_q_value, T newValue) noexcept
    {
        return _q_value.exchange(newValue, std::memory_order_acq_rel);
    }

    static inline constexpr bool isFetchAndAddNative() noexcept { return isTestAndSetNative(); }
    static inline constexpr bool isFetchAndAddWaitFree() noexcept { return false; }

    template <typename T> static inline
    T fetchAndAddRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_add(valueToAdd, std::memory_order_relaxed);
    }

    template <typename T> static inline
    T fetchAndAddAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_add(valueToAdd, std::memory_order_acquire);
    }

    template <typename T> static inline
    T fetchAndAddRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_add(valueToAdd, std::memory_order_release);
    }

    template <typename T> static inline
    T fetchAndAddOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_add(valueToAdd, std::memory_order_acq_rel);
    }

    template <typename T> static inline
    T fetchAndSubRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_sub(valueToAdd, std::memory_order_relaxed);
    }

    template <typename T> static inline
    T fetchAndSubAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_sub(valueToAdd, std::memory_order_acquire);
    }

    template <typename T> static inline
    T fetchAndSubRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_sub(valueToAdd, std::memory_order_release);
    }

    template <typename T> static inline
    T fetchAndSubOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_sub(valueToAdd, std::memory_order_acq_rel);
    }

    template <typename T> static inline
    T fetchAndAndRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_and(valueToAdd, std::memory_order_relaxed);
    }

    template <typename T> static inline
    T fetchAndAndAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_and(valueToAdd, std::memory_order_acquire);
    }

    template <typename T> static inline
    T fetchAndAndRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_and(valueToAdd, std::memory_order_release);
    }

    template <typename T> static inline
    T fetchAndAndOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_and(valueToAdd, std::memory_order_acq_rel);
    }

    template <typename T> static inline
    T fetchAndOrRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_or(valueToAdd, std::memory_order_relaxed);
    }

    template <typename T> static inline
    T fetchAndOrAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_or(valueToAdd, std::memory_order_acquire);
    }

    template <typename T> static inline
    T fetchAndOrRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_or(valueToAdd, std::memory_order_release);
    }

    template <typename T> static inline
    T fetchAndOrOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_or(valueToAdd, std::memory_order_acq_rel);
    }

    template <typename T> static inline
    T fetchAndXorRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_xor(valueToAdd, std::memory_order_relaxed);
    }

    template <typename T> static inline
    T fetchAndXorAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_xor(valueToAdd, std::memory_order_acquire);
    }

    template <typename T> static inline
    T fetchAndXorRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_xor(valueToAdd, std::memory_order_release);
    }

    template <typename T> static inline
    T fetchAndXorOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
    {
        return _q_value.fetch_xor(valueToAdd, std::memory_order_acq_rel);
    }
};





#line 488 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"



#line 492 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic_cxx11.h"
#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"








#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"

__pragma(warning(push))
__pragma(warning(disable: 4522))








#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"









#line 85 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"

#line 87 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"
#line 88 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"

template <typename T>
class QBasicAtomicInteger
{
public:
    typedef T Type;
    typedef QAtomicOps<T> Ops;
    
    static_assert(bool(QTypeInfo<T>::isIntegral), "template parameter is not an integral type");
    static_assert(bool(QAtomicOpsSupport<sizeof(T)>::IsSupported), "template parameter is an integral of a size not supported on this platform");

    typename Ops::Type _q_value;

    



#line 106 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"

    T loadRelaxed() const noexcept { return Ops::loadRelaxed(_q_value); }
    void storeRelaxed(T newValue) noexcept { Ops::storeRelaxed(_q_value, newValue); }

    T loadAcquire() const noexcept { return Ops::loadAcquire(_q_value); }
    void storeRelease(T newValue) noexcept { Ops::storeRelease(_q_value, newValue); }
    operator T() const noexcept { return loadAcquire(); }
    T operator=(T newValue) noexcept { storeRelease(newValue); return newValue; }

    static constexpr bool isReferenceCountingNative() noexcept { return Ops::isReferenceCountingNative(); }
    static constexpr bool isReferenceCountingWaitFree() noexcept { return Ops::isReferenceCountingWaitFree(); }

    bool ref() noexcept { return Ops::ref(_q_value); }
    bool deref() noexcept { return Ops::deref(_q_value); }

    static constexpr bool isTestAndSetNative() noexcept { return Ops::isTestAndSetNative(); }
    static constexpr bool isTestAndSetWaitFree() noexcept { return Ops::isTestAndSetWaitFree(); }

    bool testAndSetRelaxed(T expectedValue, T newValue) noexcept
    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); }
    bool testAndSetAcquire(T expectedValue, T newValue) noexcept
    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); }
    bool testAndSetRelease(T expectedValue, T newValue) noexcept
    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); }
    bool testAndSetOrdered(T expectedValue, T newValue) noexcept
    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); }

    bool testAndSetRelaxed(T expectedValue, T newValue, T &currentValue) noexcept
    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue, &currentValue); }
    bool testAndSetAcquire(T expectedValue, T newValue, T &currentValue) noexcept
    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue, &currentValue); }
    bool testAndSetRelease(T expectedValue, T newValue, T &currentValue) noexcept
    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue, &currentValue); }
    bool testAndSetOrdered(T expectedValue, T newValue, T &currentValue) noexcept
    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue, &currentValue); }

    static constexpr bool isFetchAndStoreNative() noexcept { return Ops::isFetchAndStoreNative(); }
    static constexpr bool isFetchAndStoreWaitFree() noexcept { return Ops::isFetchAndStoreWaitFree(); }

    T fetchAndStoreRelaxed(T newValue) noexcept
    { return Ops::fetchAndStoreRelaxed(_q_value, newValue); }
    T fetchAndStoreAcquire(T newValue) noexcept
    { return Ops::fetchAndStoreAcquire(_q_value, newValue); }
    T fetchAndStoreRelease(T newValue) noexcept
    { return Ops::fetchAndStoreRelease(_q_value, newValue); }
    T fetchAndStoreOrdered(T newValue) noexcept
    { return Ops::fetchAndStoreOrdered(_q_value, newValue); }

    static constexpr bool isFetchAndAddNative() noexcept { return Ops::isFetchAndAddNative(); }
    static constexpr bool isFetchAndAddWaitFree() noexcept { return Ops::isFetchAndAddWaitFree(); }

    T fetchAndAddRelaxed(T valueToAdd) noexcept
    { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); }
    T fetchAndAddAcquire(T valueToAdd) noexcept
    { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); }
    T fetchAndAddRelease(T valueToAdd) noexcept
    { return Ops::fetchAndAddRelease(_q_value, valueToAdd); }
    T fetchAndAddOrdered(T valueToAdd) noexcept
    { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); }

    T fetchAndSubRelaxed(T valueToAdd) noexcept
    { return Ops::fetchAndSubRelaxed(_q_value, valueToAdd); }
    T fetchAndSubAcquire(T valueToAdd) noexcept
    { return Ops::fetchAndSubAcquire(_q_value, valueToAdd); }
    T fetchAndSubRelease(T valueToAdd) noexcept
    { return Ops::fetchAndSubRelease(_q_value, valueToAdd); }
    T fetchAndSubOrdered(T valueToAdd) noexcept
    { return Ops::fetchAndSubOrdered(_q_value, valueToAdd); }

    T fetchAndAndRelaxed(T valueToAdd) noexcept
    { return Ops::fetchAndAndRelaxed(_q_value, valueToAdd); }
    T fetchAndAndAcquire(T valueToAdd) noexcept
    { return Ops::fetchAndAndAcquire(_q_value, valueToAdd); }
    T fetchAndAndRelease(T valueToAdd) noexcept
    { return Ops::fetchAndAndRelease(_q_value, valueToAdd); }
    T fetchAndAndOrdered(T valueToAdd) noexcept
    { return Ops::fetchAndAndOrdered(_q_value, valueToAdd); }

    T fetchAndOrRelaxed(T valueToAdd) noexcept
    { return Ops::fetchAndOrRelaxed(_q_value, valueToAdd); }
    T fetchAndOrAcquire(T valueToAdd) noexcept
    { return Ops::fetchAndOrAcquire(_q_value, valueToAdd); }
    T fetchAndOrRelease(T valueToAdd) noexcept
    { return Ops::fetchAndOrRelease(_q_value, valueToAdd); }
    T fetchAndOrOrdered(T valueToAdd) noexcept
    { return Ops::fetchAndOrOrdered(_q_value, valueToAdd); }

    T fetchAndXorRelaxed(T valueToAdd) noexcept
    { return Ops::fetchAndXorRelaxed(_q_value, valueToAdd); }
    T fetchAndXorAcquire(T valueToAdd) noexcept
    { return Ops::fetchAndXorAcquire(_q_value, valueToAdd); }
    T fetchAndXorRelease(T valueToAdd) noexcept
    { return Ops::fetchAndXorRelease(_q_value, valueToAdd); }
    T fetchAndXorOrdered(T valueToAdd) noexcept
    { return Ops::fetchAndXorOrdered(_q_value, valueToAdd); }

    T operator++() noexcept
    { return fetchAndAddOrdered(1) + 1; }
    T operator++(int) noexcept
    { return fetchAndAddOrdered(1); }
    T operator--() noexcept
    { return fetchAndSubOrdered(1) - 1; }
    T operator--(int) noexcept
    { return fetchAndSubOrdered(1); }

    T operator+=(T v) noexcept
    { return fetchAndAddOrdered(v) + v; }
    T operator-=(T v) noexcept
    { return fetchAndSubOrdered(v) - v; }
    T operator&=(T v) noexcept
    { return fetchAndAndOrdered(v) & v; }
    T operator|=(T v) noexcept
    { return fetchAndOrOrdered(v) | v; }
    T operator^=(T v) noexcept
    { return fetchAndXorOrdered(v) ^ v; }



    QBasicAtomicInteger() = default;
    constexpr QBasicAtomicInteger(T value) noexcept : _q_value(value) {}
    QBasicAtomicInteger(const QBasicAtomicInteger &) = delete;
    QBasicAtomicInteger &operator=(const QBasicAtomicInteger &) = delete;
    QBasicAtomicInteger &operator=(const QBasicAtomicInteger &) volatile = delete;
#line 230 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"
};
typedef QBasicAtomicInteger<int> QBasicAtomicInt;

template <typename X>
class QBasicAtomicPointer
{
public:
    typedef X *Type;
    typedef QAtomicOps<Type> Ops;
    typedef typename Ops::Type AtomicType;

    AtomicType _q_value;




#line 247 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"

    Type loadRelaxed() const noexcept { return Ops::loadRelaxed(_q_value); }
    void storeRelaxed(Type newValue) noexcept { Ops::storeRelaxed(_q_value, newValue); }

    operator Type() const noexcept { return loadAcquire(); }
    Type operator=(Type newValue) noexcept { storeRelease(newValue); return newValue; }

    
    Type loadAcquire() const noexcept { return Ops::loadAcquire(_q_value); }
    void storeRelease(Type newValue) noexcept { Ops::storeRelease(_q_value, newValue); }

    static constexpr bool isTestAndSetNative() noexcept { return Ops::isTestAndSetNative(); }
    static constexpr bool isTestAndSetWaitFree() noexcept { return Ops::isTestAndSetWaitFree(); }

    bool testAndSetRelaxed(Type expectedValue, Type newValue) noexcept
    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); }
    bool testAndSetAcquire(Type expectedValue, Type newValue) noexcept
    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); }
    bool testAndSetRelease(Type expectedValue, Type newValue) noexcept
    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); }
    bool testAndSetOrdered(Type expectedValue, Type newValue) noexcept
    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); }

    bool testAndSetRelaxed(Type expectedValue, Type newValue, Type &currentValue) noexcept
    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue, &currentValue); }
    bool testAndSetAcquire(Type expectedValue, Type newValue, Type &currentValue) noexcept
    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue, &currentValue); }
    bool testAndSetRelease(Type expectedValue, Type newValue, Type &currentValue) noexcept
    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue, &currentValue); }
    bool testAndSetOrdered(Type expectedValue, Type newValue, Type &currentValue) noexcept
    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue, &currentValue); }

    static constexpr bool isFetchAndStoreNative() noexcept { return Ops::isFetchAndStoreNative(); }
    static constexpr bool isFetchAndStoreWaitFree() noexcept { return Ops::isFetchAndStoreWaitFree(); }

    Type fetchAndStoreRelaxed(Type newValue) noexcept
    { return Ops::fetchAndStoreRelaxed(_q_value, newValue); }
    Type fetchAndStoreAcquire(Type newValue) noexcept
    { return Ops::fetchAndStoreAcquire(_q_value, newValue); }
    Type fetchAndStoreRelease(Type newValue) noexcept
    { return Ops::fetchAndStoreRelease(_q_value, newValue); }
    Type fetchAndStoreOrdered(Type newValue) noexcept
    { return Ops::fetchAndStoreOrdered(_q_value, newValue); }

    static constexpr bool isFetchAndAddNative() noexcept { return Ops::isFetchAndAddNative(); }
    static constexpr bool isFetchAndAddWaitFree() noexcept { return Ops::isFetchAndAddWaitFree(); }

    Type fetchAndAddRelaxed(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); }
    Type fetchAndAddAcquire(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); }
    Type fetchAndAddRelease(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndAddRelease(_q_value, valueToAdd); }
    Type fetchAndAddOrdered(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); }

    Type fetchAndSubRelaxed(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndSubRelaxed(_q_value, valueToAdd); }
    Type fetchAndSubAcquire(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndSubAcquire(_q_value, valueToAdd); }
    Type fetchAndSubRelease(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndSubRelease(_q_value, valueToAdd); }
    Type fetchAndSubOrdered(qptrdiff valueToAdd) noexcept
    { return Ops::fetchAndSubOrdered(_q_value, valueToAdd); }

    Type operator++() noexcept
    { return fetchAndAddOrdered(1) + 1; }
    Type operator++(int) noexcept
    { return fetchAndAddOrdered(1); }
    Type operator--() noexcept
    { return fetchAndSubOrdered(1) - 1; }
    Type operator--(int) noexcept
    { return fetchAndSubOrdered(1); }
    Type operator+=(qptrdiff valueToAdd) noexcept
    { return fetchAndAddOrdered(valueToAdd) + valueToAdd; }
    Type operator-=(qptrdiff valueToSub) noexcept
    { return fetchAndSubOrdered(valueToSub) - valueToSub; }


    QBasicAtomicPointer() = default;
    constexpr QBasicAtomicPointer(Type value) noexcept : _q_value(value) {}
    QBasicAtomicPointer(const QBasicAtomicPointer &) = delete;
    QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) = delete;
    QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) volatile = delete;
#line 332 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"
};







__pragma(warning(pop))

#line 343 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasicatomic.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



__pragma(warning(push))







template <typename T>
class QAtomicInteger : public QBasicAtomicInteger<T>
{
public:
    

    constexpr QAtomicInteger(T value = 0) noexcept : QBasicAtomicInteger<T>(value) {}





#line 71 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"

    inline QAtomicInteger(const QAtomicInteger &other) noexcept

        : QBasicAtomicInteger<T>()
#line 76 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"
    {
        this->storeRelease(other.loadAcquire());
    }

    inline QAtomicInteger &operator=(const QAtomicInteger &other) noexcept
    {
        this->storeRelease(other.loadAcquire());
        return *this;
    }








































































};

class QAtomicInt : public QAtomicInteger<int>
{
public:
    
    
    

    constexpr
#line 168 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"
    QAtomicInt(int value = 0) noexcept : QAtomicInteger<int>(value) {}
};


template <typename T>
class QAtomicPointer : public QBasicAtomicPointer<T>
{
public:

    constexpr QAtomicPointer(T *value = nullptr) noexcept : QBasicAtomicPointer<T>(value) {}





#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"
    inline QAtomicPointer(const QAtomicPointer<T> &other) noexcept

        : QBasicAtomicPointer<T>()
#line 188 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"
    {
        this->storeRelease(other.loadAcquire());
    }

    inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other) noexcept
    {
        this->storeRelease(other.loadAcquire());
        return *this;
    }

































};

__pragma(warning(pop))



#line 237 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"







template <typename T>
inline void qAtomicAssign(T *&d, T *x)
{
    if (d == x)
        return;
    x->ref.ref();
    if (!d->ref.deref())
        delete d;
    d = x;
}









template <typename T>
inline void qAtomicDetach(T *&d)
{
    if (d->ref.loadRelaxed() == 1)
        return;
    T *x = d;
    d = new T(*d);
    if (!x->ref.deref())
        delete x;
}


#line 276 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"
#pragma external_header(pop)
#line 1308 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"







































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"




#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"










































































































































































































































#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"





namespace QtGlobalStatic {
enum GuardValues {
    Destroyed = -2,
    Initialized = -1,
    Uninitialized = 0,
    Initializing = 1
};
}

















#line 77 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"

#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"
















































#line 128 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"


template <typename T, T *(&innerFunction)(), QBasicAtomicInt &guard>
struct QGlobalStatic
{
    typedef T Type;

    bool isDestroyed() const { return guard.loadRelaxed() <= QtGlobalStatic::Destroyed; }
    bool exists() const { return guard.loadRelaxed() == QtGlobalStatic::Initialized; }
    operator Type *() { if (isDestroyed()) return nullptr; return innerFunction(); }
    Type *operator()() { if (isDestroyed()) return nullptr; return innerFunction(); }
    Type *operator->()
    {
      ((!isDestroyed()) ? static_cast<void>(0) : qt_assert_x("Q_GLOBAL_STATIC", "The global static was used after being destroyed", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h", 141));
      return innerFunction();
    }
    Type &operator*()
    {
      ((!isDestroyed()) ? static_cast<void>(0) : qt_assert_x("Q_GLOBAL_STATIC", "The global static was used after being destroyed", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h", 146));
      return *innerFunction();
    }
};















#line 166 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobalstatic.h"
#pragma external_header(pop)
#line 1309 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnumeric.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnumeric.h"



__declspec(dllimport)  bool qIsInf(double d);
__declspec(dllimport)  bool qIsNaN(double d);
__declspec(dllimport)  bool qIsFinite(double d);
__declspec(dllimport)  int qFpClassify(double val);
__declspec(dllimport)  bool qIsInf(float f);
__declspec(dllimport)  bool qIsNaN(float f);
__declspec(dllimport)  bool qIsFinite(float f);
__declspec(dllimport)  int qFpClassify(float val);

__declspec(dllimport)  double qSNaN();
#line 58 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnumeric.h"
__declspec(dllimport)  double qQNaN();
__declspec(dllimport)  double qInf();

__declspec(dllimport) quint32 qFloatDistance(float a, float b);
__declspec(dllimport) quint64 qFloatDistance(double a, double b);




#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnumeric.h"




#line 73 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnumeric.h"
#pragma external_header(pop)
#line 1310 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qversiontagging.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"



































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qversiontagging.h"























#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qversiontagging.h"
















#line 83 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qversiontagging.h"



#line 87 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qversiontagging.h"



#line 91 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qversiontagging.h"
#pragma external_header(pop)
#line 1311 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 1313 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#line 1314 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"

#line 1316 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qglobal.h"
#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"




class QString;

struct QLatin1Char
{
public:
    constexpr inline explicit QLatin1Char(char c) noexcept : ch(c) {}
    constexpr inline char toLatin1() const noexcept { return ch; }
    constexpr inline ushort unicode() const noexcept { return ushort(uchar(ch)); }

private:
    char ch;
};

constexpr inline bool operator==(char lhs, QLatin1Char rhs) noexcept { return lhs == rhs.toLatin1(); }
constexpr inline bool operator!=(char lhs, QLatin1Char rhs) noexcept { return lhs != rhs.toLatin1(); }
constexpr inline bool operator<=(char lhs, QLatin1Char rhs) noexcept { return lhs <= rhs.toLatin1(); }
constexpr inline bool operator>=(char lhs, QLatin1Char rhs) noexcept { return lhs >= rhs.toLatin1(); }
constexpr inline bool operator< (char lhs, QLatin1Char rhs) noexcept { return lhs <  rhs.toLatin1(); }
constexpr inline bool operator> (char lhs, QLatin1Char rhs) noexcept { return lhs >  rhs.toLatin1(); }

constexpr inline bool operator==(QLatin1Char lhs, char rhs) noexcept { return lhs.toLatin1() == rhs; }
constexpr inline bool operator!=(QLatin1Char lhs, char rhs) noexcept { return lhs.toLatin1() != rhs; }
constexpr inline bool operator<=(QLatin1Char lhs, char rhs) noexcept { return lhs.toLatin1() <= rhs; }
constexpr inline bool operator>=(QLatin1Char lhs, char rhs) noexcept { return lhs.toLatin1() >= rhs; }
constexpr inline bool operator< (QLatin1Char lhs, char rhs) noexcept { return lhs.toLatin1() <  rhs; }
constexpr inline bool operator> (QLatin1Char lhs, char rhs) noexcept { return lhs.toLatin1() >  rhs; }

class __declspec(dllimport) QChar {
public:
    enum SpecialCharacter {
        Null = 0x0000,
        Tabulation = 0x0009,
        LineFeed = 0x000a,
        FormFeed = 0x000c,
        CarriageReturn = 0x000d,
        Space = 0x0020,
        Nbsp = 0x00a0,
        SoftHyphen = 0x00ad,
        ReplacementCharacter = 0xfffd,
        ObjectReplacementCharacter = 0xfffc,
        ByteOrderMark = 0xfeff,
        ByteOrderSwapped = 0xfffe,
        ParagraphSeparator = 0x2029,
        LineSeparator = 0x2028,
        LastValidCodePoint = 0x10ffff
    };

    constexpr QChar() noexcept : ucs(0) {}
    constexpr QChar(ushort rc) noexcept : ucs(rc) {} 
    constexpr QChar(uchar c, uchar r) noexcept : ucs(ushort((r << 8) | c)) {}
    constexpr QChar(short rc) noexcept : ucs(ushort(rc)) {} 
    constexpr QChar(uint rc) noexcept : ucs(ushort(rc & 0xffff)) {}
    constexpr QChar(int rc) noexcept : ucs(ushort(rc & 0xffff)) {}
    constexpr QChar(SpecialCharacter s) noexcept : ucs(ushort(s)) {} 
    constexpr QChar(QLatin1Char ch) noexcept : ucs(ch.unicode()) {} 

    constexpr QChar(char16_t ch) noexcept : ucs(ushort(ch)) {} 
#line 106 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"

    static_assert(bool(sizeof(wchar_t) == sizeof(ushort)), "sizeof(wchar_t) == sizeof(ushort)");
#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"


    constexpr QChar(wchar_t ch) noexcept : ucs(ushort(ch)) {} 
#line 113 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"


     constexpr explicit QChar(char c) noexcept : ucs(uchar(c)) { }

     constexpr explicit QChar(uchar c) noexcept : ucs(c) { }
#line 120 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
#line 121 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
    

    enum Category
    {
        Mark_NonSpacing,          
        Mark_SpacingCombining,    
        Mark_Enclosing,           

        Number_DecimalDigit,      
        Number_Letter,            
        Number_Other,             

        Separator_Space,          
        Separator_Line,           
        Separator_Paragraph,      

        Other_Control,            
        Other_Format,             
        Other_Surrogate,          
        Other_PrivateUse,         
        Other_NotAssigned,        

        Letter_Uppercase,         
        Letter_Lowercase,         
        Letter_Titlecase,         
        Letter_Modifier,          
        Letter_Other,             

        Punctuation_Connector,    
        Punctuation_Dash,         
        Punctuation_Open,         
        Punctuation_Close,        
        Punctuation_InitialQuote, 
        Punctuation_FinalQuote,   
        Punctuation_Other,        

        Symbol_Math,              
        Symbol_Currency,          
        Symbol_Modifier,          
        Symbol_Other              
    };

    enum Script
    {
        Script_Unknown,
        Script_Inherited,
        Script_Common,

        Script_Latin,
        Script_Greek,
        Script_Cyrillic,
        Script_Armenian,
        Script_Hebrew,
        Script_Arabic,
        Script_Syriac,
        Script_Thaana,
        Script_Devanagari,
        Script_Bengali,
        Script_Gurmukhi,
        Script_Gujarati,
        Script_Oriya,
        Script_Tamil,
        Script_Telugu,
        Script_Kannada,
        Script_Malayalam,
        Script_Sinhala,
        Script_Thai,
        Script_Lao,
        Script_Tibetan,
        Script_Myanmar,
        Script_Georgian,
        Script_Hangul,
        Script_Ethiopic,
        Script_Cherokee,
        Script_CanadianAboriginal,
        Script_Ogham,
        Script_Runic,
        Script_Khmer,
        Script_Mongolian,
        Script_Hiragana,
        Script_Katakana,
        Script_Bopomofo,
        Script_Han,
        Script_Yi,
        Script_OldItalic,
        Script_Gothic,
        Script_Deseret,
        Script_Tagalog,
        Script_Hanunoo,
        Script_Buhid,
        Script_Tagbanwa,
        Script_Coptic,

        
        Script_Limbu,
        Script_TaiLe,
        Script_LinearB,
        Script_Ugaritic,
        Script_Shavian,
        Script_Osmanya,
        Script_Cypriot,
        Script_Braille,

        
        Script_Buginese,
        Script_NewTaiLue,
        Script_Glagolitic,
        Script_Tifinagh,
        Script_SylotiNagri,
        Script_OldPersian,
        Script_Kharoshthi,

        
        Script_Balinese,
        Script_Cuneiform,
        Script_Phoenician,
        Script_PhagsPa,
        Script_Nko,

        
        Script_Sundanese,
        Script_Lepcha,
        Script_OlChiki,
        Script_Vai,
        Script_Saurashtra,
        Script_KayahLi,
        Script_Rejang,
        Script_Lycian,
        Script_Carian,
        Script_Lydian,
        Script_Cham,

        
        Script_TaiTham,
        Script_TaiViet,
        Script_Avestan,
        Script_EgyptianHieroglyphs,
        Script_Samaritan,
        Script_Lisu,
        Script_Bamum,
        Script_Javanese,
        Script_MeeteiMayek,
        Script_ImperialAramaic,
        Script_OldSouthArabian,
        Script_InscriptionalParthian,
        Script_InscriptionalPahlavi,
        Script_OldTurkic,
        Script_Kaithi,

        
        Script_Batak,
        Script_Brahmi,
        Script_Mandaic,

        
        Script_Chakma,
        Script_MeroiticCursive,
        Script_MeroiticHieroglyphs,
        Script_Miao,
        Script_Sharada,
        Script_SoraSompeng,
        Script_Takri,

        
        Script_CaucasianAlbanian,
        Script_BassaVah,
        Script_Duployan,
        Script_Elbasan,
        Script_Grantha,
        Script_PahawhHmong,
        Script_Khojki,
        Script_LinearA,
        Script_Mahajani,
        Script_Manichaean,
        Script_MendeKikakui,
        Script_Modi,
        Script_Mro,
        Script_OldNorthArabian,
        Script_Nabataean,
        Script_Palmyrene,
        Script_PauCinHau,
        Script_OldPermic,
        Script_PsalterPahlavi,
        Script_Siddham,
        Script_Khudawadi,
        Script_Tirhuta,
        Script_WarangCiti,

        
        Script_Ahom,
        Script_AnatolianHieroglyphs,
        Script_Hatran,
        Script_Multani,
        Script_OldHungarian,
        Script_SignWriting,

        
        Script_Adlam,
        Script_Bhaiksuki,
        Script_Marchen,
        Script_Newa,
        Script_Osage,
        Script_Tangut,

        
        Script_MasaramGondi,
        Script_Nushu,
        Script_Soyombo,
        Script_ZanabazarSquare,

        
        Script_Dogra,
        Script_GunjalaGondi,
        Script_HanifiRohingya,
        Script_Makasar,
        Script_Medefaidrin,
        Script_OldSogdian,
        Script_Sogdian,
        Script_Elymaic,
        Script_Nandinagari,
        Script_NyiakengPuachueHmong,
        Script_Wancho,

        
        Script_Chorasmian,
        Script_DivesAkuru,
        Script_KhitanSmallScript,
        Script_Yezidi,

        ScriptCount
    };

    enum Direction
    {
        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN,
        DirLRI, DirRLI, DirFSI, DirPDI
    };

    enum Decomposition
    {
        NoDecomposition,
        Canonical,
        Font,
        NoBreak,
        Initial,
        Medial,
        Final,
        Isolated,
        Circle,
        Super,
        Sub,
        Vertical,
        Wide,
        Narrow,
        Small,
        Square,
        Compat,
        Fraction
    };

    enum JoiningType {
        Joining_None,
        Joining_Causing,
        Joining_Dual,
        Joining_Right,
        Joining_Left,
        Joining_Transparent
    };






#line 397 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"

    enum CombiningClass
    {
        Combining_BelowLeftAttached       = 200,
        Combining_BelowAttached           = 202,
        Combining_BelowRightAttached      = 204,
        Combining_LeftAttached            = 208,
        Combining_RightAttached           = 210,
        Combining_AboveLeftAttached       = 212,
        Combining_AboveAttached           = 214,
        Combining_AboveRightAttached      = 216,

        Combining_BelowLeft               = 218,
        Combining_Below                   = 220,
        Combining_BelowRight              = 222,
        Combining_Left                    = 224,
        Combining_Right                   = 226,
        Combining_AboveLeft               = 228,
        Combining_Above                   = 230,
        Combining_AboveRight              = 232,

        Combining_DoubleBelow             = 233,
        Combining_DoubleAbove             = 234,
        Combining_IotaSubscript           = 240
    };

    enum UnicodeVersion {
        Unicode_Unassigned,
        Unicode_1_1,
        Unicode_2_0,
        Unicode_2_1_2,
        Unicode_3_0,
        Unicode_3_1,
        Unicode_3_2,
        Unicode_4_0,
        Unicode_4_1,
        Unicode_5_0,
        Unicode_5_1,
        Unicode_5_2,
        Unicode_6_0,
        Unicode_6_1,
        Unicode_6_2,
        Unicode_6_3,
        Unicode_7_0,
        Unicode_8_0,
        Unicode_9_0,
        Unicode_10_0,
        Unicode_11_0,
        Unicode_12_0,
        Unicode_12_1,
        Unicode_13_0
    };
    

    inline Category category() const noexcept { return QChar::category(ucs); }
    inline Direction direction() const noexcept { return QChar::direction(ucs); }
    inline JoiningType joiningType() const noexcept { return QChar::joiningType(ucs); }













#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
    inline unsigned char combiningClass() const noexcept { return QChar::combiningClass(ucs); }

    inline QChar mirroredChar() const noexcept { return QChar(QChar::mirroredChar(ucs)); }
    inline bool hasMirrored() const noexcept { return QChar::hasMirrored(ucs); }

    QString decomposition() const;
    inline Decomposition decompositionTag() const noexcept { return QChar::decompositionTag(ucs); }

    inline int digitValue() const noexcept { return QChar::digitValue(ucs); }
    inline QChar toLower() const noexcept { return QChar(QChar::toLower(ucs)); }
    inline QChar toUpper() const noexcept { return QChar(QChar::toUpper(ucs)); }
    inline QChar toTitleCase() const noexcept { return QChar(QChar::toTitleCase(ucs)); }
    inline QChar toCaseFolded() const noexcept { return QChar(QChar::toCaseFolded(ucs)); }

    inline Script script() const noexcept { return QChar::script(ucs); }

    inline UnicodeVersion unicodeVersion() const noexcept { return QChar::unicodeVersion(ucs); }



#line 489 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
    constexpr inline char toLatin1() const noexcept { return ucs > 0xff ? '\0' : char(ucs); }
    constexpr inline ushort unicode() const noexcept { return ucs; }
    constexpr inline ushort &unicode() noexcept { return ucs; }




#line 497 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
    static constexpr inline QChar fromLatin1(char c) noexcept { return QChar(ushort(uchar(c))); }

    constexpr inline bool isNull() const noexcept { return ucs == 0; }

    inline bool isPrint() const noexcept { return QChar::isPrint(ucs); }
    constexpr inline bool isSpace() const noexcept { return QChar::isSpace(ucs); }
    inline bool isMark() const noexcept { return QChar::isMark(ucs); }
    inline bool isPunct() const noexcept { return QChar::isPunct(ucs); }
    inline bool isSymbol() const noexcept { return QChar::isSymbol(ucs); }
    constexpr inline bool isLetter() const noexcept { return QChar::isLetter(ucs); }
    constexpr inline bool isNumber() const noexcept { return QChar::isNumber(ucs); }
    constexpr inline bool isLetterOrNumber() const noexcept { return QChar::isLetterOrNumber(ucs); }
    constexpr inline bool isDigit() const noexcept { return QChar::isDigit(ucs); }
    constexpr inline bool isLower() const noexcept { return QChar::isLower(ucs); }
    constexpr inline bool isUpper() const noexcept { return QChar::isUpper(ucs); }
    constexpr inline bool isTitleCase() const noexcept { return QChar::isTitleCase(ucs); }

    constexpr inline bool isNonCharacter() const noexcept { return QChar::isNonCharacter(ucs); }
    constexpr inline bool isHighSurrogate() const noexcept { return QChar::isHighSurrogate(ucs); }
    constexpr inline bool isLowSurrogate() const noexcept { return QChar::isLowSurrogate(ucs); }
    constexpr inline bool isSurrogate() const noexcept { return QChar::isSurrogate(ucs); }

    constexpr inline uchar cell() const noexcept { return uchar(ucs & 0xff); }
    constexpr inline uchar row() const noexcept { return uchar((ucs>>8)&0xff); }
    constexpr inline void setCell(uchar acell) noexcept { ucs = ushort((ucs & 0xff00) + acell); }
    constexpr inline void setRow(uchar arow) noexcept { ucs = ushort((ushort(arow)<<8) + (ucs&0xff)); }

    static constexpr inline bool isNonCharacter(uint ucs4) noexcept
    {
        return ucs4 >= 0xfdd0 && (ucs4 <= 0xfdef || (ucs4 & 0xfffe) == 0xfffe);
    }
    static constexpr inline bool isHighSurrogate(uint ucs4) noexcept
    {
        return ((ucs4 & 0xfffffc00) == 0xd800);
    }
    static constexpr inline bool isLowSurrogate(uint ucs4) noexcept
    {
        return ((ucs4 & 0xfffffc00) == 0xdc00);
    }
    static constexpr inline bool isSurrogate(uint ucs4) noexcept
    {
        return (ucs4 - 0xd800u < 2048u);
    }
    static constexpr inline bool requiresSurrogates(uint ucs4) noexcept
    {
        return (ucs4 >= 0x10000);
    }
    static constexpr inline uint surrogateToUcs4(ushort high, ushort low) noexcept
    {
        return (uint(high)<<10) + low - 0x35fdc00;
    }
    static constexpr inline uint surrogateToUcs4(QChar high, QChar low) noexcept
    {
        return surrogateToUcs4(high.ucs, low.ucs);
    }
    static constexpr inline ushort highSurrogate(uint ucs4) noexcept
    {
        return ushort((ucs4>>10) + 0xd7c0);
    }
    static constexpr inline ushort lowSurrogate(uint ucs4) noexcept
    {
        return ushort(ucs4%0x400 + 0xdc00);
    }

    static Category  category(uint ucs4) noexcept ;
    static Direction  direction(uint ucs4) noexcept ;
    static JoiningType  joiningType(uint ucs4) noexcept ;


#line 567 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
    static unsigned char  combiningClass(uint ucs4) noexcept ;

    static uint  mirroredChar(uint ucs4) noexcept ;
    static bool  hasMirrored(uint ucs4) noexcept ;

    static QString  decomposition(uint ucs4);
    static Decomposition  decompositionTag(uint ucs4) noexcept ;

    static int  digitValue(uint ucs4) noexcept ;
    static uint  toLower(uint ucs4) noexcept ;
    static uint  toUpper(uint ucs4) noexcept ;
    static uint  toTitleCase(uint ucs4) noexcept ;
    static uint  toCaseFolded(uint ucs4) noexcept ;

    static Script  script(uint ucs4) noexcept ;

    static UnicodeVersion  unicodeVersion(uint ucs4) noexcept ;

    static UnicodeVersion  currentUnicodeVersion() noexcept ;

    static bool  isPrint(uint ucs4) noexcept ;
    static constexpr inline bool isSpace(uint ucs4) noexcept 
    {
        
        return ucs4 == 0x20 || (ucs4 <= 0x0d && ucs4 >= 0x09)
                || (ucs4 > 127 && (ucs4 == 0x85 || ucs4 == 0xa0 || QChar::isSpace_helper(ucs4)));
    }
    static bool  isMark(uint ucs4) noexcept ;
    static bool  isPunct(uint ucs4) noexcept ;
    static bool  isSymbol(uint ucs4) noexcept ;
    static constexpr inline bool isLetter(uint ucs4) noexcept 
    {
        return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))
                || (ucs4 > 127 && QChar::isLetter_helper(ucs4));
    }
    static constexpr inline bool isNumber(uint ucs4) noexcept 
    { return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::isNumber_helper(ucs4)); }
    static constexpr inline bool isLetterOrNumber(uint ucs4) noexcept 
    {
        return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))
                || (ucs4 >= '0' && ucs4 <= '9')
                || (ucs4 > 127 && QChar::isLetterOrNumber_helper(ucs4));
    }
    static constexpr inline bool isDigit(uint ucs4) noexcept 
    { return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::category(ucs4) == Number_DecimalDigit); }
    static constexpr inline bool isLower(uint ucs4) noexcept 
    { return (ucs4 <= 'z' && ucs4 >= 'a') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Lowercase); }
    static constexpr inline bool isUpper(uint ucs4) noexcept 
    { return (ucs4 <= 'Z' && ucs4 >= 'A') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Uppercase); }
    static constexpr inline bool isTitleCase(uint ucs4) noexcept 
    { return ucs4 > 127 && QChar::category(ucs4) == Letter_Titlecase; }

private:
    static bool  isSpace_helper(uint ucs4) noexcept ;
    static bool  isLetter_helper(uint ucs4) noexcept ;
    static bool  isNumber_helper(uint ucs4) noexcept ;
    static bool  isLetterOrNumber_helper(uint ucs4) noexcept ;






    friend constexpr bool operator==(QChar, QChar) noexcept;
    friend constexpr bool operator< (QChar, QChar) noexcept;
    ushort ucs;
};

template<> class QTypeInfo<QChar > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QChar>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QChar>(), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QChar >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QChar) }; static inline const char *name() { return "QChar"; } };

constexpr inline bool operator==(QChar c1, QChar c2) noexcept { return c1.ucs == c2.ucs; }
constexpr inline bool operator< (QChar c1, QChar c2) noexcept { return c1.ucs <  c2.ucs; }

constexpr inline bool operator!=(QChar c1, QChar c2) noexcept { return !operator==(c1, c2); }
constexpr inline bool operator>=(QChar c1, QChar c2) noexcept { return !operator< (c1, c2); }
constexpr inline bool operator> (QChar c1, QChar c2) noexcept { return  operator< (c2, c1); }
constexpr inline bool operator<=(QChar c1, QChar c2) noexcept { return !operator< (c2, c1); }


constexpr inline bool operator==(QChar lhs, std::nullptr_t) noexcept { return lhs.isNull(); }
constexpr inline bool operator< (QChar,     std::nullptr_t) noexcept { return false; }
constexpr inline bool operator==(std::nullptr_t, QChar rhs) noexcept { return rhs.isNull(); }
constexpr inline bool operator< (std::nullptr_t, QChar rhs) noexcept { return !rhs.isNull(); }

constexpr inline bool operator!=(QChar lhs, std::nullptr_t) noexcept { return !operator==(lhs, nullptr); }
constexpr inline bool operator>=(QChar lhs, std::nullptr_t) noexcept { return !operator< (lhs, nullptr); }
constexpr inline bool operator> (QChar lhs, std::nullptr_t) noexcept { return  operator< (nullptr, lhs); }
constexpr inline bool operator<=(QChar lhs, std::nullptr_t) noexcept { return !operator< (nullptr, lhs); }

constexpr inline bool operator!=(std::nullptr_t, QChar rhs) noexcept { return !operator==(nullptr, rhs); }
constexpr inline bool operator>=(std::nullptr_t, QChar rhs) noexcept { return !operator< (nullptr, rhs); }
constexpr inline bool operator> (std::nullptr_t, QChar rhs) noexcept { return  operator< (rhs, nullptr); }
constexpr inline bool operator<=(std::nullptr_t, QChar rhs) noexcept { return !operator< (rhs, nullptr); }


__declspec(dllimport) QDataStream &operator<<(QDataStream &, QChar);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QChar &);
#line 665 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"



#line 669 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qchar.h"
#pragma external_header(pop)
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h"




namespace QtPrivate
{

class RefCount
{
public:
    inline bool ref() noexcept {
        int count = atomic.loadRelaxed();

        if (count == 0) 
            return false;
#line 60 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h"
        if (count != -1) 
            atomic.ref();
        return true;
    }

    inline bool deref() noexcept {
        int count = atomic.loadRelaxed();

        if (count == 0) 
            return false;
#line 71 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h"
        if (count == -1) 
            return true;
        return atomic.deref();
    }


    bool setSharable(bool sharable) noexcept
    {
        ((!isShared()) ? static_cast<void>(0) : qt_assert("!isShared()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h", 79));
        if (sharable)
            return atomic.testAndSetRelaxed(0, 1);
        else
            return atomic.testAndSetRelaxed(1, 0);
    }

    bool isSharable() const noexcept
    {
        
        return atomic.loadRelaxed() != 0;
    }
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h"

    bool isStatic() const noexcept
    {
        
        return atomic.loadRelaxed() == -1;
    }

    bool isShared() const noexcept
    {
        int count = atomic.loadRelaxed();
        return (count != 1) && (count != 0);
    }

    void initializeOwned() noexcept { atomic.storeRelaxed(1); }
    void initializeUnsharable() noexcept { atomic.storeRelaxed(0); }

    QBasicAtomicInt atomic;
};

}





#line 118 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qrefcount.h"
#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"














































#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"




struct QMetaObject;
const QMetaObject *qt_getQtMetaObject() noexcept; 







#line 62 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"


namespace


#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
Qt {




#line 74 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"

    enum GlobalColor {
        color0,
        color1,
        black,
        white,
        darkGray,
        gray,
        lightGray,
        red,
        green,
        blue,
        cyan,
        magenta,
        yellow,
        darkRed,
        darkGreen,
        darkBlue,
        darkCyan,
        darkMagenta,
        darkYellow,
        transparent
    };

    enum KeyboardModifier {
        NoModifier           = 0x00000000,
        ShiftModifier        = 0x02000000,
        ControlModifier      = 0x04000000,
        AltModifier          = 0x08000000,
        MetaModifier         = 0x10000000,
        KeypadModifier       = 0x20000000,
        GroupSwitchModifier  = 0x40000000,
        
        KeyboardModifierMask = 0xfe000000
    };
    typedef QFlags<KeyboardModifier> KeyboardModifiers;
    constexpr inline QFlags<KeyboardModifiers::enum_type> operator|(KeyboardModifiers::enum_type f1, KeyboardModifiers::enum_type f2) noexcept { return QFlags<KeyboardModifiers::enum_type>(f1) | f2; } constexpr inline QFlags<KeyboardModifiers::enum_type> operator|(KeyboardModifiers::enum_type f1, QFlags<KeyboardModifiers::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(KeyboardModifiers::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    
    
    
    
    
    enum Modifier {
        META          = Qt::MetaModifier,
        SHIFT         = Qt::ShiftModifier,
        CTRL          = Qt::ControlModifier,
        ALT           = Qt::AltModifier,
        MODIFIER_MASK = KeyboardModifierMask,
        UNICODE_ACCEL = 0x00000000
    };

    enum MouseButton {
        NoButton         = 0x00000000,
        LeftButton       = 0x00000001,
        RightButton      = 0x00000002,
        MiddleButton     = 0x00000004,


#line 134 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        BackButton       = 0x00000008,
        XButton1         = BackButton,
        ExtraButton1     = XButton1,
        ForwardButton    = 0x00000010,
        XButton2         = ForwardButton,
        ExtraButton2     = ForwardButton,
        TaskButton       = 0x00000020,
        ExtraButton3     = TaskButton,
        ExtraButton4     = 0x00000040,
        ExtraButton5     = 0x00000080,
        ExtraButton6     = 0x00000100,
        ExtraButton7     = 0x00000200,
        ExtraButton8     = 0x00000400,
        ExtraButton9     = 0x00000800,
        ExtraButton10    = 0x00001000,
        ExtraButton11    = 0x00002000,
        ExtraButton12    = 0x00004000,
        ExtraButton13    = 0x00008000,
        ExtraButton14    = 0x00010000,
        ExtraButton15    = 0x00020000,
        ExtraButton16    = 0x00040000,
        ExtraButton17    = 0x00080000,
        ExtraButton18    = 0x00100000,
        ExtraButton19    = 0x00200000,
        ExtraButton20    = 0x00400000,
        ExtraButton21    = 0x00800000,
        ExtraButton22    = 0x01000000,
        ExtraButton23    = 0x02000000,
        ExtraButton24    = 0x04000000,
        AllButtons       = 0x07ffffff,
        MaxMouseButton   = ExtraButton24,
        
        MouseButtonMask  = 0xffffffff
    };
    typedef QFlags<MouseButton> MouseButtons;
    constexpr inline QFlags<MouseButtons::enum_type> operator|(MouseButtons::enum_type f1, MouseButtons::enum_type f2) noexcept { return QFlags<MouseButtons::enum_type>(f1) | f2; } constexpr inline QFlags<MouseButtons::enum_type> operator|(MouseButtons::enum_type f1, QFlags<MouseButtons::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(MouseButtons::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum Orientation {
        Horizontal = 0x1,
        Vertical = 0x2
    };

    typedef QFlags<Orientation> Orientations;
    constexpr inline QFlags<Orientations::enum_type> operator|(Orientations::enum_type f1, Orientations::enum_type f2) noexcept { return QFlags<Orientations::enum_type>(f1) | f2; } constexpr inline QFlags<Orientations::enum_type> operator|(Orientations::enum_type f1, QFlags<Orientations::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Orientations::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum FocusPolicy {
        NoFocus = 0,
        TabFocus = 0x1,
        ClickFocus = 0x2,
        StrongFocus = TabFocus | ClickFocus | 0x8,
        WheelFocus = StrongFocus | 0x4
    };

    enum TabFocusBehavior {
        NoTabFocus           = 0x00,
        TabFocusTextControls = 0x01,
        TabFocusListControls = 0x02,
        TabFocusAllControls  = 0xff
    };

    enum SortOrder {
        AscendingOrder,
        DescendingOrder
    };

    enum SplitBehaviorFlags {
        KeepEmptyParts = 0,
        SkipEmptyParts = 0x1,
    };
    typedef QFlags<SplitBehaviorFlags> SplitBehavior;
    constexpr inline QFlags<SplitBehavior::enum_type> operator|(SplitBehavior::enum_type f1, SplitBehavior::enum_type f2) noexcept { return QFlags<SplitBehavior::enum_type>(f1) | f2; } constexpr inline QFlags<SplitBehavior::enum_type> operator|(SplitBehavior::enum_type f1, QFlags<SplitBehavior::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(SplitBehavior::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum TileRule {
        StretchTile,
        RepeatTile,
        RoundTile
    };

    
    
    

    enum AlignmentFlag {
        AlignLeft = 0x0001,
        AlignLeading = AlignLeft,
        AlignRight = 0x0002,
        AlignTrailing = AlignRight,
        AlignHCenter = 0x0004,
        AlignJustify = 0x0008,
        AlignAbsolute = 0x0010,
        AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute,

        AlignTop = 0x0020,
        AlignBottom = 0x0040,
        AlignVCenter = 0x0080,
        AlignBaseline = 0x0100,
        
        
        
        
        AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter | AlignBaseline,

        AlignCenter = AlignVCenter | AlignHCenter
    };
    typedef QFlags<AlignmentFlag> Alignment;

    enum TextFlag {
        TextSingleLine = 0x0100,
        TextDontClip = 0x0200,
        TextExpandTabs = 0x0400,
        TextShowMnemonic = 0x0800,
        TextWordWrap = 0x1000,
        TextWrapAnywhere = 0x2000,
        TextDontPrint = 0x4000,
        TextIncludeTrailingSpaces = 0x08000000,
        TextHideMnemonic = 0x8000,
        TextJustificationForced = 0x10000,
        TextForceLeftToRight = 0x20000,
        TextForceRightToLeft = 0x40000,
        
        
        TextLongestVariant = 0x80000



#line 260 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
    };
    constexpr inline int operator | (AlignmentFlag lhs, TextFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<AlignmentFlag>(lhs) | std::underlying_type_t<TextFlag>(rhs)); } constexpr inline int operator & (AlignmentFlag lhs, TextFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<AlignmentFlag>(lhs) & std::underlying_type_t<TextFlag>(rhs)); } constexpr inline int operator ^ (AlignmentFlag lhs, TextFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<AlignmentFlag>(lhs) ^ std::underlying_type_t<TextFlag>(rhs)); } constexpr inline int operator | (TextFlag lhs, AlignmentFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextFlag>(lhs) | std::underlying_type_t<AlignmentFlag>(rhs)); } constexpr inline int operator & (TextFlag lhs, AlignmentFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextFlag>(lhs) & std::underlying_type_t<AlignmentFlag>(rhs)); } constexpr inline int operator ^ (TextFlag lhs, AlignmentFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextFlag>(lhs) ^ std::underlying_type_t<AlignmentFlag>(rhs)); }
    
    
    constexpr inline QFlags<Alignment::enum_type> operator|(Alignment::enum_type f1, Alignment::enum_type f2) noexcept { return QFlags<Alignment::enum_type>(f1) | f2; } constexpr inline QFlags<Alignment::enum_type> operator|(Alignment::enum_type f1, QFlags<Alignment::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Alignment::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum TextElideMode {
        ElideLeft,
        ElideRight,
        ElideMiddle,
        ElideNone
    };
    constexpr inline int operator | (TextElideMode lhs, TextFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextElideMode>(lhs) | std::underlying_type_t<TextFlag>(rhs)); } constexpr inline int operator & (TextElideMode lhs, TextFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextElideMode>(lhs) & std::underlying_type_t<TextFlag>(rhs)); } constexpr inline int operator ^ (TextElideMode lhs, TextFlag rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextElideMode>(lhs) ^ std::underlying_type_t<TextFlag>(rhs)); } constexpr inline int operator | (TextFlag lhs, TextElideMode rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextFlag>(lhs) | std::underlying_type_t<TextElideMode>(rhs)); } constexpr inline int operator & (TextFlag lhs, TextElideMode rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextFlag>(lhs) & std::underlying_type_t<TextElideMode>(rhs)); } constexpr inline int operator ^ (TextFlag lhs, TextElideMode rhs) noexcept { return static_cast<int>(std::underlying_type_t<TextFlag>(lhs) ^ std::underlying_type_t<TextElideMode>(rhs)); }

    enum WhiteSpaceMode {
        WhiteSpaceNormal,
        WhiteSpacePre,
        WhiteSpaceNoWrap,
        WhiteSpaceModeUndefined = -1
    };

    enum HitTestAccuracy { ExactHit, FuzzyHit };

    enum WindowType {
        Widget = 0x00000000,
        Window = 0x00000001,
        Dialog = 0x00000002 | Window,
        Sheet = 0x00000004 | Window,
        Drawer = Sheet | Dialog,
        Popup = 0x00000008 | Window,
        Tool = Popup | Dialog,
        ToolTip = Popup | Sheet,
        SplashScreen = ToolTip | Dialog,
        Desktop = 0x00000010 | Window,
        SubWindow = 0x00000012,
        ForeignWindow = 0x00000020 | Window,
        CoverWindow = 0x00000040 | Window,

        WindowType_Mask = 0x000000ff,
        MSWindowsFixedSizeDialogHint = 0x00000100,
        MSWindowsOwnDC = 0x00000200,
        BypassWindowManagerHint = 0x00000400,
        X11BypassWindowManagerHint = BypassWindowManagerHint,
        FramelessWindowHint = 0x00000800,
        WindowTitleHint = 0x00001000,
        WindowSystemMenuHint = 0x00002000,
        WindowMinimizeButtonHint = 0x00004000,
        WindowMaximizeButtonHint = 0x00008000,
        WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint,
        WindowContextHelpButtonHint = 0x00010000,
        WindowShadeButtonHint = 0x00020000,
        WindowStaysOnTopHint = 0x00040000,
        WindowTransparentForInput = 0x00080000,
        WindowOverridesSystemGestures = 0x00100000,
        WindowDoesNotAcceptFocus = 0x00200000,
        MaximizeUsingFullscreenGeometryHint = 0x00400000,

        CustomizeWindowHint = 0x02000000,
        WindowStaysOnBottomHint = 0x04000000,
        WindowCloseButtonHint = 0x08000000,
        MacWindowToolBarButtonHint = 0x10000000,
        BypassGraphicsProxyWidget = 0x20000000,
        NoDropShadowWindowHint = 0x40000000,
        WindowFullscreenButtonHint = 0x80000000
    };

    typedef QFlags<WindowType> WindowFlags;
    constexpr inline QFlags<WindowFlags::enum_type> operator|(WindowFlags::enum_type f1, WindowFlags::enum_type f2) noexcept { return QFlags<WindowFlags::enum_type>(f1) | f2; } constexpr inline QFlags<WindowFlags::enum_type> operator|(WindowFlags::enum_type f1, QFlags<WindowFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(WindowFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum WindowState {
        WindowNoState    = 0x00000000,
        WindowMinimized  = 0x00000001,
        WindowMaximized  = 0x00000002,
        WindowFullScreen = 0x00000004,
        WindowActive     = 0x00000008
    };

    typedef QFlags<WindowState> WindowStates;
    constexpr inline QFlags<WindowStates::enum_type> operator|(WindowStates::enum_type f1, WindowStates::enum_type f2) noexcept { return QFlags<WindowStates::enum_type>(f1) | f2; } constexpr inline QFlags<WindowStates::enum_type> operator|(WindowStates::enum_type f1, QFlags<WindowStates::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(WindowStates::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum ApplicationState {
        ApplicationSuspended    = 0x00000000,
        ApplicationHidden       = 0x00000001,
        ApplicationInactive     = 0x00000002,
        ApplicationActive       = 0x00000004
    };

    typedef QFlags<ApplicationState> ApplicationStates;

    enum ScreenOrientation {
        PrimaryOrientation           = 0x00000000,
        PortraitOrientation          = 0x00000001,
        LandscapeOrientation         = 0x00000002,
        InvertedPortraitOrientation  = 0x00000004,
        InvertedLandscapeOrientation = 0x00000008
    };

    typedef QFlags<ScreenOrientation> ScreenOrientations;
    constexpr inline QFlags<ScreenOrientations::enum_type> operator|(ScreenOrientations::enum_type f1, ScreenOrientations::enum_type f2) noexcept { return QFlags<ScreenOrientations::enum_type>(f1) | f2; } constexpr inline QFlags<ScreenOrientations::enum_type> operator|(ScreenOrientations::enum_type f1, QFlags<ScreenOrientations::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(ScreenOrientations::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum WidgetAttribute {
        WA_Disabled = 0,
        WA_UnderMouse = 1,
        WA_MouseTracking = 2,


#line 367 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_OpaquePaintEvent = 4,


#line 371 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_StaticContents = 5,
        WA_LaidOut = 7,
        WA_PaintOnScreen = 8,
        WA_NoSystemBackground = 9,
        WA_UpdatesDisabled = 10,
        WA_Mapped = 11,


#line 380 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_InputMethodEnabled = 14,
        WA_WState_Visible = 15,
        WA_WState_Hidden = 16,

        WA_ForceDisabled = 32,
        WA_KeyCompression = 33,
        WA_PendingMoveEvent = 34,
        WA_PendingResizeEvent = 35,
        WA_SetPalette = 36,
        WA_SetFont = 37,
        WA_SetCursor = 38,
        WA_NoChildEventsFromChildren = 39,
        WA_WindowModified = 41,
        WA_Resized = 42,
        WA_Moved = 43,
        WA_PendingUpdate = 44,
        WA_InvalidSize = 45,



#line 401 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_CustomWhatsThis = 47,
        WA_LayoutOnEntireRect = 48,
        WA_OutsideWSRange = 49,
        WA_GrabbedShortcut = 50,
        WA_TransparentForMouseEvents = 51,
        WA_PaintUnclipped = 52,
        WA_SetWindowIcon = 53,
        WA_NoMouseReplay = 54,
        WA_DeleteOnClose = 55,
        WA_RightToLeft = 56,
        WA_SetLayoutDirection = 57,
        WA_NoChildEventsForParent = 58,
        WA_ForceUpdatesDisabled = 59,

        WA_WState_Created = 60,
        WA_WState_CompressKeys = 61,
        WA_WState_InPaintEvent = 62,
        WA_WState_Reparented = 63,
        WA_WState_ConfigPending = 64,
        WA_WState_Polished = 66,


#line 424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_WState_OwnSizePolicy = 68,
        WA_WState_ExplicitShowHide = 69,

        WA_ShowModal = 70, 
        WA_MouseNoMask = 71,
        WA_GroupLeader = 72, 
        WA_NoMousePropagation = 73, 
        WA_Hover = 74,
        WA_InputMethodTransparent = 75, 
        WA_QuitOnClose = 76,

        WA_KeyboardFocusChange = 77,

        WA_AcceptDrops = 78,
        WA_DropSiteRegistered = 79, 


#line 442 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"

        WA_WindowPropagation = 80,

        WA_NoX11EventCompression = 81,
        WA_TintedBackground = 82,
        WA_X11OpenGLOverlay = 83,
        WA_AlwaysShowToolTips = 84,
        WA_MacOpaqueSizeGrip = 85,
        WA_SetStyle = 86,

        WA_SetLocale = 87,
        WA_MacShowFocusRect = 88,

        WA_MacNormalSize = 89,  
        WA_MacSmallSize = 90,   
        WA_MacMiniSize = 91,    

        WA_LayoutUsesWidgetRect = 92,
        WA_StyledBackground = 93, 


#line 464 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_CanHostQMdiSubWindowTitleBar = 95, 

        WA_MacAlwaysShowToolWindow = 96, 

        WA_StyleSheet = 97, 

        WA_ShowWithoutActivating = 98,

        WA_X11BypassTransientForHint = 99,

        WA_NativeWindow = 100,
        WA_DontCreateNativeAncestors = 101,

        WA_MacVariableSize = 102,    

        WA_DontShowOnScreen = 103,

        
        WA_X11NetWmWindowTypeDesktop = 104,
        WA_X11NetWmWindowTypeDock = 105,
        WA_X11NetWmWindowTypeToolBar = 106,
        WA_X11NetWmWindowTypeMenu = 107,
        WA_X11NetWmWindowTypeUtility = 108,
        WA_X11NetWmWindowTypeSplash = 109,
        WA_X11NetWmWindowTypeDialog = 110,
        WA_X11NetWmWindowTypeDropDownMenu = 111,
        WA_X11NetWmWindowTypePopupMenu = 112,
        WA_X11NetWmWindowTypeToolTip = 113,
        WA_X11NetWmWindowTypeNotification = 114,
        WA_X11NetWmWindowTypeCombo = 115,
        WA_X11NetWmWindowTypeDND = 116,


#line 498 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        WA_SetWindowModality = 118,
        WA_WState_WindowOpacitySet = 119, 
        WA_TranslucentBackground = 120,

        WA_AcceptTouchEvents = 121,
        WA_WState_AcceptedTouchBeginEvent = 122,
        WA_TouchPadAcceptSingleTouchEvents = 123,

        WA_X11DoNotAcceptFocus = 126,
        WA_MacNoShadow = 127,

        WA_AlwaysStackOnTop = 128,

        WA_TabletTracking = 129,

        WA_ContentsMarginsRespectsSafeArea = 130,

        WA_StyleSheetTarget = 131,

        
        WA_AttributeCount
    };

    enum ApplicationAttribute
    {
        AA_ImmediateWidgetCreation = 0,


#line 527 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        AA_DontShowIconsInMenus = 2,
        AA_NativeWindows = 3,
        AA_DontCreateNativeWidgetSiblings = 4,
        AA_PluginApplication = 5,


#line 534 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        AA_DontUseNativeMenuBar = 6,
        AA_MacDontSwapCtrlAndMeta = 7,
        AA_Use96Dpi = 8,
        AA_DisableNativeVirtualKeyboard = 9,


#line 541 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        AA_SynthesizeTouchForUnhandledMouseEvents = 11,
        AA_SynthesizeMouseForUnhandledTouchEvents = 12,
        AA_UseHighDpiPixmaps = 13,
        AA_ForceRasterWidgets = 14,
        AA_UseDesktopOpenGL = 15,
        AA_UseOpenGLES = 16,
        AA_UseSoftwareOpenGL = 17,
        AA_ShareOpenGLContexts = 18,
        AA_SetPalette = 19,
        AA_EnableHighDpiScaling = 20,
        AA_DisableHighDpiScaling = 21,
        AA_UseStyleSheetPropagationInWidgetStyles = 22,
        AA_DontUseNativeDialogs = 23,
        AA_SynthesizeMouseForUnhandledTabletEvents = 24,
        AA_CompressHighFrequencyEvents = 25,
        AA_DontCheckOpenGLContextThreadAffinity = 26,
        AA_DisableShaderDiskCache = 27,
        AA_DontShowShortcutsInContextMenus = 28,
        AA_CompressTabletEvents = 29,
        AA_DisableWindowContextHelpButton = 30, 
        AA_DisableSessionManager = 31,

        
        AA_AttributeCount
    };


    
    

    enum ImageConversionFlag {
        ColorMode_Mask          = 0x00000003,
        AutoColor               = 0x00000000,
        ColorOnly               = 0x00000003,
        MonoOnly                = 0x00000002,
        

        AlphaDither_Mask        = 0x0000000c,
        ThresholdAlphaDither    = 0x00000000,
        OrderedAlphaDither      = 0x00000004,
        DiffuseAlphaDither      = 0x00000008,
        NoAlpha                 = 0x0000000c, 

        Dither_Mask             = 0x00000030,
        DiffuseDither           = 0x00000000,
        OrderedDither           = 0x00000010,
        ThresholdDither         = 0x00000020,
        

        DitherMode_Mask         = 0x000000c0,
        AutoDither              = 0x00000000,
        PreferDither            = 0x00000040,
        AvoidDither             = 0x00000080,

        NoOpaqueDetection       = 0x00000100,
        NoFormatConversion      = 0x00000200
    };
    typedef QFlags<ImageConversionFlag> ImageConversionFlags;
    constexpr inline QFlags<ImageConversionFlags::enum_type> operator|(ImageConversionFlags::enum_type f1, ImageConversionFlags::enum_type f2) noexcept { return QFlags<ImageConversionFlags::enum_type>(f1) | f2; } constexpr inline QFlags<ImageConversionFlags::enum_type> operator|(ImageConversionFlags::enum_type f1, QFlags<ImageConversionFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(ImageConversionFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum BGMode {
        TransparentMode,
        OpaqueMode
    };

    enum Key {
        Key_Escape = 0x01000000,                
        Key_Tab = 0x01000001,
        Key_Backtab = 0x01000002,
        Key_Backspace = 0x01000003,
        Key_Return = 0x01000004,
        Key_Enter = 0x01000005,
        Key_Insert = 0x01000006,
        Key_Delete = 0x01000007,
        Key_Pause = 0x01000008,
        Key_Print = 0x01000009,               
        Key_SysReq = 0x0100000a,
        Key_Clear = 0x0100000b,
        Key_Home = 0x01000010,                
        Key_End = 0x01000011,
        Key_Left = 0x01000012,
        Key_Up = 0x01000013,
        Key_Right = 0x01000014,
        Key_Down = 0x01000015,
        Key_PageUp = 0x01000016,
        Key_PageDown = 0x01000017,
        Key_Shift = 0x01000020,                
        Key_Control = 0x01000021,
        Key_Meta = 0x01000022,
        Key_Alt = 0x01000023,
        Key_CapsLock = 0x01000024,
        Key_NumLock = 0x01000025,
        Key_ScrollLock = 0x01000026,
        Key_F1 = 0x01000030,                
        Key_F2 = 0x01000031,
        Key_F3 = 0x01000032,
        Key_F4 = 0x01000033,
        Key_F5 = 0x01000034,
        Key_F6 = 0x01000035,
        Key_F7 = 0x01000036,
        Key_F8 = 0x01000037,
        Key_F9 = 0x01000038,
        Key_F10 = 0x01000039,
        Key_F11 = 0x0100003a,
        Key_F12 = 0x0100003b,
        Key_F13 = 0x0100003c,
        Key_F14 = 0x0100003d,
        Key_F15 = 0x0100003e,
        Key_F16 = 0x0100003f,
        Key_F17 = 0x01000040,
        Key_F18 = 0x01000041,
        Key_F19 = 0x01000042,
        Key_F20 = 0x01000043,
        Key_F21 = 0x01000044,
        Key_F22 = 0x01000045,
        Key_F23 = 0x01000046,
        Key_F24 = 0x01000047,
        Key_F25 = 0x01000048,                
        Key_F26 = 0x01000049,
        Key_F27 = 0x0100004a,
        Key_F28 = 0x0100004b,
        Key_F29 = 0x0100004c,
        Key_F30 = 0x0100004d,
        Key_F31 = 0x0100004e,
        Key_F32 = 0x0100004f,
        Key_F33 = 0x01000050,
        Key_F34 = 0x01000051,
        Key_F35 = 0x01000052,
        Key_Super_L = 0x01000053,                 
        Key_Super_R = 0x01000054,
        Key_Menu = 0x01000055,
        Key_Hyper_L = 0x01000056,
        Key_Hyper_R = 0x01000057,
        Key_Help = 0x01000058,
        Key_Direction_L = 0x01000059,
        Key_Direction_R = 0x01000060,
        Key_Space = 0x20,                
        Key_Any = Key_Space,
        Key_Exclam = 0x21,
        Key_QuoteDbl = 0x22,
        Key_NumberSign = 0x23,
        Key_Dollar = 0x24,
        Key_Percent = 0x25,
        Key_Ampersand = 0x26,
        Key_Apostrophe = 0x27,
        Key_ParenLeft = 0x28,
        Key_ParenRight = 0x29,
        Key_Asterisk = 0x2a,
        Key_Plus = 0x2b,
        Key_Comma = 0x2c,
        Key_Minus = 0x2d,
        Key_Period = 0x2e,
        Key_Slash = 0x2f,
        Key_0 = 0x30,
        Key_1 = 0x31,
        Key_2 = 0x32,
        Key_3 = 0x33,
        Key_4 = 0x34,
        Key_5 = 0x35,
        Key_6 = 0x36,
        Key_7 = 0x37,
        Key_8 = 0x38,
        Key_9 = 0x39,
        Key_Colon = 0x3a,
        Key_Semicolon = 0x3b,
        Key_Less = 0x3c,
        Key_Equal = 0x3d,
        Key_Greater = 0x3e,
        Key_Question = 0x3f,
        Key_At = 0x40,
        Key_A = 0x41,
        Key_B = 0x42,
        Key_C = 0x43,
        Key_D = 0x44,
        Key_E = 0x45,
        Key_F = 0x46,
        Key_G = 0x47,
        Key_H = 0x48,
        Key_I = 0x49,
        Key_J = 0x4a,
        Key_K = 0x4b,
        Key_L = 0x4c,
        Key_M = 0x4d,
        Key_N = 0x4e,
        Key_O = 0x4f,
        Key_P = 0x50,
        Key_Q = 0x51,
        Key_R = 0x52,
        Key_S = 0x53,
        Key_T = 0x54,
        Key_U = 0x55,
        Key_V = 0x56,
        Key_W = 0x57,
        Key_X = 0x58,
        Key_Y = 0x59,
        Key_Z = 0x5a,
        Key_BracketLeft = 0x5b,
        Key_Backslash = 0x5c,
        Key_BracketRight = 0x5d,
        Key_AsciiCircum = 0x5e,
        Key_Underscore = 0x5f,
        Key_QuoteLeft = 0x60,
        Key_BraceLeft = 0x7b,
        Key_Bar = 0x7c,
        Key_BraceRight = 0x7d,
        Key_AsciiTilde = 0x7e,

        Key_nobreakspace = 0x0a0,
        Key_exclamdown = 0x0a1,
        Key_cent = 0x0a2,
        Key_sterling = 0x0a3,
        Key_currency = 0x0a4,
        Key_yen = 0x0a5,
        Key_brokenbar = 0x0a6,
        Key_section = 0x0a7,
        Key_diaeresis = 0x0a8,
        Key_copyright = 0x0a9,
        Key_ordfeminine = 0x0aa,
        Key_guillemotleft = 0x0ab,        
        Key_notsign = 0x0ac,
        Key_hyphen = 0x0ad,
        Key_registered = 0x0ae,
        Key_macron = 0x0af,
        Key_degree = 0x0b0,
        Key_plusminus = 0x0b1,
        Key_twosuperior = 0x0b2,
        Key_threesuperior = 0x0b3,
        Key_acute = 0x0b4,
        Key_mu = 0x0b5,
        Key_paragraph = 0x0b6,
        Key_periodcentered = 0x0b7,
        Key_cedilla = 0x0b8,
        Key_onesuperior = 0x0b9,
        Key_masculine = 0x0ba,
        Key_guillemotright = 0x0bb,        
        Key_onequarter = 0x0bc,
        Key_onehalf = 0x0bd,
        Key_threequarters = 0x0be,
        Key_questiondown = 0x0bf,
        Key_Agrave = 0x0c0,
        Key_Aacute = 0x0c1,
        Key_Acircumflex = 0x0c2,
        Key_Atilde = 0x0c3,
        Key_Adiaeresis = 0x0c4,
        Key_Aring = 0x0c5,
        Key_AE = 0x0c6,
        Key_Ccedilla = 0x0c7,
        Key_Egrave = 0x0c8,
        Key_Eacute = 0x0c9,
        Key_Ecircumflex = 0x0ca,
        Key_Ediaeresis = 0x0cb,
        Key_Igrave = 0x0cc,
        Key_Iacute = 0x0cd,
        Key_Icircumflex = 0x0ce,
        Key_Idiaeresis = 0x0cf,
        Key_ETH = 0x0d0,
        Key_Ntilde = 0x0d1,
        Key_Ograve = 0x0d2,
        Key_Oacute = 0x0d3,
        Key_Ocircumflex = 0x0d4,
        Key_Otilde = 0x0d5,
        Key_Odiaeresis = 0x0d6,
        Key_multiply = 0x0d7,
        Key_Ooblique = 0x0d8,
        Key_Ugrave = 0x0d9,
        Key_Uacute = 0x0da,
        Key_Ucircumflex = 0x0db,
        Key_Udiaeresis = 0x0dc,
        Key_Yacute = 0x0dd,
        Key_THORN = 0x0de,
        Key_ssharp = 0x0df,
        Key_division = 0x0f7,
        Key_ydiaeresis = 0x0ff,

        
        
        

        
        Key_AltGr               = 0x01001103,
        Key_Multi_key           = 0x01001120,  
        Key_Codeinput           = 0x01001137,
        Key_SingleCandidate     = 0x0100113c,
        Key_MultipleCandidate   = 0x0100113d,
        Key_PreviousCandidate   = 0x0100113e,

        
        Key_Mode_switch         = 0x0100117e,  
        

        
        Key_Kanji               = 0x01001121,  
        Key_Muhenkan            = 0x01001122,  
        
        Key_Henkan              = 0x01001123,  
        Key_Romaji              = 0x01001124,  
        Key_Hiragana            = 0x01001125,  
        Key_Katakana            = 0x01001126,  
        Key_Hiragana_Katakana   = 0x01001127,  
        Key_Zenkaku             = 0x01001128,  
        Key_Hankaku             = 0x01001129,  
        Key_Zenkaku_Hankaku     = 0x0100112a,  
        Key_Touroku             = 0x0100112b,  
        Key_Massyo              = 0x0100112c,  
        Key_Kana_Lock           = 0x0100112d,  
        Key_Kana_Shift          = 0x0100112e,  
        Key_Eisu_Shift          = 0x0100112f,  
        Key_Eisu_toggle         = 0x01001130,  
        
        
        

        
        
        
        

        Key_Hangul              = 0x01001131,  
        Key_Hangul_Start        = 0x01001132,  
        Key_Hangul_End          = 0x01001133,  
        Key_Hangul_Hanja        = 0x01001134,  
        Key_Hangul_Jamo         = 0x01001135,  
        Key_Hangul_Romaja       = 0x01001136,  
        
        Key_Hangul_Jeonja       = 0x01001138,  
        Key_Hangul_Banja        = 0x01001139,  
        Key_Hangul_PreHanja     = 0x0100113a,  
        Key_Hangul_PostHanja    = 0x0100113b,  
        
        
        
        Key_Hangul_Special      = 0x0100113f,  
        

        
        Key_Dead_Grave          = 0x01001250,
        Key_Dead_Acute          = 0x01001251,
        Key_Dead_Circumflex     = 0x01001252,
        Key_Dead_Tilde          = 0x01001253,
        Key_Dead_Macron         = 0x01001254,
        Key_Dead_Breve          = 0x01001255,
        Key_Dead_Abovedot       = 0x01001256,
        Key_Dead_Diaeresis      = 0x01001257,
        Key_Dead_Abovering      = 0x01001258,
        Key_Dead_Doubleacute    = 0x01001259,
        Key_Dead_Caron          = 0x0100125a,
        Key_Dead_Cedilla        = 0x0100125b,
        Key_Dead_Ogonek         = 0x0100125c,
        Key_Dead_Iota           = 0x0100125d,
        Key_Dead_Voiced_Sound   = 0x0100125e,
        Key_Dead_Semivoiced_Sound = 0x0100125f,
        Key_Dead_Belowdot       = 0x01001260,
        Key_Dead_Hook           = 0x01001261,
        Key_Dead_Horn           = 0x01001262,
        Key_Dead_Stroke         = 0x01001263,
        Key_Dead_Abovecomma     = 0x01001264,
        Key_Dead_Abovereversedcomma = 0x01001265,
        Key_Dead_Doublegrave    = 0x01001266,
        Key_Dead_Belowring      = 0x01001267,
        Key_Dead_Belowmacron    = 0x01001268,
        Key_Dead_Belowcircumflex = 0x01001269,
        Key_Dead_Belowtilde     = 0x0100126a,
        Key_Dead_Belowbreve     = 0x0100126b,
        Key_Dead_Belowdiaeresis = 0x0100126c,
        Key_Dead_Invertedbreve  = 0x0100126d,
        Key_Dead_Belowcomma     = 0x0100126e,
        Key_Dead_Currency       = 0x0100126f,
        Key_Dead_a              = 0x01001280,
        Key_Dead_A              = 0x01001281,
        Key_Dead_e              = 0x01001282,
        Key_Dead_E              = 0x01001283,
        Key_Dead_i              = 0x01001284,
        Key_Dead_I              = 0x01001285,
        Key_Dead_o              = 0x01001286,
        Key_Dead_O              = 0x01001287,
        Key_Dead_u              = 0x01001288,
        Key_Dead_U              = 0x01001289,
        Key_Dead_Small_Schwa    = 0x0100128a,
        Key_Dead_Capital_Schwa  = 0x0100128b,
        Key_Dead_Greek          = 0x0100128c,
        Key_Dead_Lowline        = 0x01001290,
        Key_Dead_Aboveverticalline = 0x01001291,
        Key_Dead_Belowverticalline = 0x01001292,
        Key_Dead_Longsolidusoverlay = 0x01001293,

        
        Key_Back  = 0x01000061,
        Key_Forward  = 0x01000062,
        Key_Stop  = 0x01000063,
        Key_Refresh  = 0x01000064,
        Key_VolumeDown = 0x01000070,
        Key_VolumeMute  = 0x01000071,
        Key_VolumeUp = 0x01000072,
        Key_BassBoost = 0x01000073,
        Key_BassUp = 0x01000074,
        Key_BassDown = 0x01000075,
        Key_TrebleUp = 0x01000076,
        Key_TrebleDown = 0x01000077,
        Key_MediaPlay  = 0x01000080,
        Key_MediaStop  = 0x01000081,
        Key_MediaPrevious  = 0x01000082,
        Key_MediaNext  = 0x01000083,
        Key_MediaRecord = 0x01000084,
        Key_MediaPause = 0x1000085,
        Key_MediaTogglePlayPause = 0x1000086,
        Key_HomePage  = 0x01000090,
        Key_Favorites  = 0x01000091,
        Key_Search  = 0x01000092,
        Key_Standby = 0x01000093,
        Key_OpenUrl = 0x01000094,
        Key_LaunchMail  = 0x010000a0,
        Key_LaunchMedia = 0x010000a1,
        Key_Launch0  = 0x010000a2,
        Key_Launch1  = 0x010000a3,
        Key_Launch2  = 0x010000a4,
        Key_Launch3  = 0x010000a5,
        Key_Launch4  = 0x010000a6,
        Key_Launch5  = 0x010000a7,
        Key_Launch6  = 0x010000a8,
        Key_Launch7  = 0x010000a9,
        Key_Launch8  = 0x010000aa,
        Key_Launch9  = 0x010000ab,
        Key_LaunchA  = 0x010000ac,
        Key_LaunchB  = 0x010000ad,
        Key_LaunchC  = 0x010000ae,
        Key_LaunchD  = 0x010000af,
        Key_LaunchE  = 0x010000b0,
        Key_LaunchF  = 0x010000b1,
        Key_MonBrightnessUp = 0x010000b2,
        Key_MonBrightnessDown = 0x010000b3,
        Key_KeyboardLightOnOff = 0x010000b4,
        Key_KeyboardBrightnessUp = 0x010000b5,
        Key_KeyboardBrightnessDown = 0x010000b6,
        Key_PowerOff = 0x010000b7,
        Key_WakeUp = 0x010000b8,
        Key_Eject = 0x010000b9,
        Key_ScreenSaver = 0x010000ba,
        Key_WWW = 0x010000bb,
        Key_Memo = 0x010000bc,
        Key_LightBulb = 0x010000bd,
        Key_Shop = 0x010000be,
        Key_History = 0x010000bf,
        Key_AddFavorite = 0x010000c0,
        Key_HotLinks = 0x010000c1,
        Key_BrightnessAdjust = 0x010000c2,
        Key_Finance = 0x010000c3,
        Key_Community = 0x010000c4,
        Key_AudioRewind = 0x010000c5, 
        Key_BackForward = 0x010000c6,
        Key_ApplicationLeft = 0x010000c7,
        Key_ApplicationRight = 0x010000c8,
        Key_Book = 0x010000c9,
        Key_CD = 0x010000ca,
        Key_Calculator = 0x010000cb,
        Key_ToDoList = 0x010000cc,
        Key_ClearGrab = 0x010000cd,
        Key_Close = 0x010000ce,
        Key_Copy = 0x010000cf,
        Key_Cut = 0x010000d0,
        Key_Display = 0x010000d1, 
        Key_DOS = 0x010000d2,
        Key_Documents = 0x010000d3,
        Key_Excel = 0x010000d4,
        Key_Explorer = 0x010000d5,
        Key_Game = 0x010000d6,
        Key_Go = 0x010000d7,
        Key_iTouch = 0x010000d8,
        Key_LogOff = 0x010000d9,
        Key_Market = 0x010000da,
        Key_Meeting = 0x010000db,
        Key_MenuKB = 0x010000dc,
        Key_MenuPB = 0x010000dd,
        Key_MySites = 0x010000de,
        Key_News = 0x010000df,
        Key_OfficeHome = 0x010000e0,
        Key_Option = 0x010000e1,
        Key_Paste = 0x010000e2,
        Key_Phone = 0x010000e3,
        Key_Calendar = 0x010000e4,
        Key_Reply = 0x010000e5,
        Key_Reload = 0x010000e6,
        Key_RotateWindows = 0x010000e7,
        Key_RotationPB = 0x010000e8,
        Key_RotationKB = 0x010000e9,
        Key_Save = 0x010000ea,
        Key_Send = 0x010000eb,
        Key_Spell = 0x010000ec,
        Key_SplitScreen = 0x010000ed,
        Key_Support = 0x010000ee,
        Key_TaskPane = 0x010000ef,
        Key_Terminal = 0x010000f0,
        Key_Tools = 0x010000f1,
        Key_Travel = 0x010000f2,
        Key_Video = 0x010000f3,
        Key_Word = 0x010000f4,
        Key_Xfer = 0x010000f5,
        Key_ZoomIn = 0x010000f6,
        Key_ZoomOut = 0x010000f7,
        Key_Away = 0x010000f8,
        Key_Messenger = 0x010000f9,
        Key_WebCam = 0x010000fa,
        Key_MailForward = 0x010000fb,
        Key_Pictures = 0x010000fc,
        Key_Music = 0x010000fd,
        Key_Battery = 0x010000fe,
        Key_Bluetooth = 0x010000ff,
        Key_WLAN = 0x01000100,
        Key_UWB = 0x01000101,
        Key_AudioForward = 0x01000102, 
        Key_AudioRepeat = 0x01000103, 
        Key_AudioRandomPlay = 0x01000104, 
        Key_Subtitle = 0x01000105,
        Key_AudioCycleTrack = 0x01000106,
        Key_Time = 0x01000107,
        Key_Hibernate = 0x01000108,
        Key_View = 0x01000109,
        Key_TopMenu = 0x0100010a,
        Key_PowerDown = 0x0100010b,
        Key_Suspend = 0x0100010c,
        Key_ContrastAdjust = 0x0100010d,

        Key_LaunchG  = 0x0100010e,
        Key_LaunchH  = 0x0100010f,

        Key_TouchpadToggle = 0x01000110,
        Key_TouchpadOn = 0x01000111,
        Key_TouchpadOff = 0x01000112,

        Key_MicMute = 0x01000113,

        Key_Red = 0x01000114,
        Key_Green = 0x01000115,
        Key_Yellow = 0x01000116,
        Key_Blue = 0x01000117,

        Key_ChannelUp = 0x01000118,
        Key_ChannelDown = 0x01000119,

        Key_Guide    = 0x0100011a,
        Key_Info     = 0x0100011b,
        Key_Settings = 0x0100011c,

        Key_MicVolumeUp   = 0x0100011d,
        Key_MicVolumeDown = 0x0100011e,

        Key_New      = 0x01000120,
        Key_Open     = 0x01000121,
        Key_Find     = 0x01000122,
        Key_Undo     = 0x01000123,
        Key_Redo     = 0x01000124,

        Key_MediaLast = 0x0100ffff,

        
        Key_Select = 0x01010000,
        Key_Yes = 0x01010001,
        Key_No = 0x01010002,

        
        Key_Cancel  = 0x01020001,
        Key_Printer = 0x01020002,
        Key_Execute = 0x01020003,
        Key_Sleep   = 0x01020004,
        Key_Play    = 0x01020005, 
        Key_Zoom    = 0x01020006,
        
        
        
        Key_Exit    = 0x0102000a,

        
        Key_Context1 = 0x01100000,
        Key_Context2 = 0x01100001,
        Key_Context3 = 0x01100002,
        Key_Context4 = 0x01100003,
        Key_Call = 0x01100004,      
        Key_Hangup = 0x01100005,    
        Key_Flip = 0x01100006,
        Key_ToggleCallHangup = 0x01100007, 
        Key_VoiceDial = 0x01100008,
        Key_LastNumberRedial = 0x01100009,

        Key_Camera = 0x01100020,
        Key_CameraFocus = 0x01100021,

        Key_unknown = 0x01ffffff
    };

    enum ArrowType {
        NoArrow,
        UpArrow,
        DownArrow,
        LeftArrow,
        RightArrow
    };

    enum PenStyle { 
        NoPen,
        SolidLine,
        DashLine,
        DotLine,
        DashDotLine,
        DashDotDotLine,
        CustomDashLine

        , MPenStyle = 0x0f
#line 1148 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
    };

    enum PenCapStyle { 
        FlatCap = 0x00,
        SquareCap = 0x10,
        RoundCap = 0x20,
        MPenCapStyle = 0x30
    };

    enum PenJoinStyle { 
        MiterJoin = 0x00,
        BevelJoin = 0x40,
        RoundJoin = 0x80,
        SvgMiterJoin = 0x100,
        MPenJoinStyle = 0x1c0
    };

    enum BrushStyle { 
        NoBrush,
        SolidPattern,
        Dense1Pattern,
        Dense2Pattern,
        Dense3Pattern,
        Dense4Pattern,
        Dense5Pattern,
        Dense6Pattern,
        Dense7Pattern,
        HorPattern,
        VerPattern,
        CrossPattern,
        BDiagPattern,
        FDiagPattern,
        DiagCrossPattern,
        LinearGradientPattern,
        RadialGradientPattern,
        ConicalGradientPattern,
        TexturePattern = 24
    };

    enum SizeMode {
        AbsoluteSize,
        RelativeSize
    };

    enum UIEffect {
        UI_General,
        UI_AnimateMenu,
        UI_FadeMenu,
        UI_AnimateCombo,
        UI_AnimateTooltip,
        UI_FadeTooltip,
        UI_AnimateToolBox
    };

    enum CursorShape {
        ArrowCursor,
        UpArrowCursor,
        CrossCursor,
        WaitCursor,
        IBeamCursor,
        SizeVerCursor,
        SizeHorCursor,
        SizeBDiagCursor,
        SizeFDiagCursor,
        SizeAllCursor,
        BlankCursor,
        SplitVCursor,
        SplitHCursor,
        PointingHandCursor,
        ForbiddenCursor,
        WhatsThisCursor,
        BusyCursor,
        OpenHandCursor,
        ClosedHandCursor,
        DragCopyCursor,
        DragMoveCursor,
        DragLinkCursor,
        LastCursor = DragLinkCursor,
        BitmapCursor = 24,
        CustomCursor = 25
    };

    enum TextFormat {
        PlainText,
        RichText,
        AutoText,
        MarkdownText
    };

    enum AspectRatioMode {
        IgnoreAspectRatio,
        KeepAspectRatio,
        KeepAspectRatioByExpanding
    };

    enum DockWidgetArea {
        LeftDockWidgetArea = 0x1,
        RightDockWidgetArea = 0x2,
        TopDockWidgetArea = 0x4,
        BottomDockWidgetArea = 0x8,

        DockWidgetArea_Mask = 0xf,
        AllDockWidgetAreas = DockWidgetArea_Mask,
        NoDockWidgetArea = 0
    };
    enum DockWidgetAreaSizes {
        NDockWidgetAreas = 4
    };

    typedef QFlags<DockWidgetArea> DockWidgetAreas;
    constexpr inline QFlags<DockWidgetAreas::enum_type> operator|(DockWidgetAreas::enum_type f1, DockWidgetAreas::enum_type f2) noexcept { return QFlags<DockWidgetAreas::enum_type>(f1) | f2; } constexpr inline QFlags<DockWidgetAreas::enum_type> operator|(DockWidgetAreas::enum_type f1, QFlags<DockWidgetAreas::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(DockWidgetAreas::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum ToolBarArea {
        LeftToolBarArea = 0x1,
        RightToolBarArea = 0x2,
        TopToolBarArea = 0x4,
        BottomToolBarArea = 0x8,

        ToolBarArea_Mask = 0xf,
        AllToolBarAreas = ToolBarArea_Mask,
        NoToolBarArea = 0
    };

    enum ToolBarAreaSizes {
        NToolBarAreas = 4
    };

    typedef QFlags<ToolBarArea> ToolBarAreas;
    constexpr inline QFlags<ToolBarAreas::enum_type> operator|(ToolBarAreas::enum_type f1, ToolBarAreas::enum_type f2) noexcept { return QFlags<ToolBarAreas::enum_type>(f1) | f2; } constexpr inline QFlags<ToolBarAreas::enum_type> operator|(ToolBarAreas::enum_type f1, QFlags<ToolBarAreas::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(ToolBarAreas::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum DateFormat {
        TextDate,      
        ISODate,       








#line 1290 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        RFC2822Date = 8, 
        ISODateWithMs
    };

    enum TimeSpec {
        LocalTime,
        UTC,
        OffsetFromUTC,
        TimeZone
    };

    enum DayOfWeek {
        Monday = 1,
        Tuesday = 2,
        Wednesday = 3,
        Thursday = 4,
        Friday = 5,
        Saturday = 6,
        Sunday = 7
    };

    enum ScrollBarPolicy {
        ScrollBarAsNeeded,
        ScrollBarAlwaysOff,
        ScrollBarAlwaysOn
    };

    enum CaseSensitivity {
        CaseInsensitive,
        CaseSensitive
    };

    enum Corner {
        TopLeftCorner = 0x00000,
        TopRightCorner = 0x00001,
        BottomLeftCorner = 0x00002,
        BottomRightCorner = 0x00003
    };

    enum Edge {
        TopEdge = 0x00001,
        LeftEdge = 0x00002,
        RightEdge = 0x00004,
        BottomEdge = 0x00008
    };

    typedef QFlags<Edge> Edges;
    constexpr inline QFlags<Edges::enum_type> operator|(Edges::enum_type f1, Edges::enum_type f2) noexcept { return QFlags<Edges::enum_type>(f1) | f2; } constexpr inline QFlags<Edges::enum_type> operator|(Edges::enum_type f1, QFlags<Edges::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Edges::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum ConnectionType {
        AutoConnection,
        DirectConnection,
        QueuedConnection,
        BlockingQueuedConnection,
        UniqueConnection =  0x80
    };

    enum ShortcutContext {
        WidgetShortcut,
        WindowShortcut,
        ApplicationShortcut,
        WidgetWithChildrenShortcut
    };

    enum FillRule {
        OddEvenFill,
        WindingFill
    };

    enum MaskMode {
        MaskInColor,
        MaskOutColor
    };

    enum ClipOperation {
        NoClip,
        ReplaceClip,
        IntersectClip
    };

    
    enum ItemSelectionMode {
        ContainsItemShape = 0x0,
        IntersectsItemShape = 0x1,
        ContainsItemBoundingRect = 0x2,
        IntersectsItemBoundingRect = 0x3
    };

    enum ItemSelectionOperation {
        ReplaceSelection,
        AddToSelection
    };

    enum TransformationMode {
        FastTransformation,
        SmoothTransformation
    };

    enum Axis {
        XAxis,
        YAxis,
        ZAxis
    };

    enum FocusReason {
        MouseFocusReason,
        TabFocusReason,
        BacktabFocusReason,
        ActiveWindowFocusReason,
        PopupFocusReason,
        ShortcutFocusReason,
        MenuBarFocusReason,
        OtherFocusReason,
        NoFocusReason
    };

    enum ContextMenuPolicy {
        NoContextMenu,
        DefaultContextMenu,
        ActionsContextMenu,
        CustomContextMenu,
        PreventContextMenu
    };

    enum InputMethodQuery {
        ImEnabled = 0x1,
        ImCursorRectangle = 0x2,


#line 1420 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        ImFont = 0x4,
        ImCursorPosition = 0x8,
        ImSurroundingText = 0x10,
        ImCurrentSelection = 0x20,
        ImMaximumTextLength = 0x40,
        ImAnchorPosition = 0x80,
        ImHints = 0x100,
        ImPreferredLanguage = 0x200,

        ImAbsolutePosition = 0x400,
        ImTextBeforeCursor = 0x800,
        ImTextAfterCursor = 0x1000,
        ImEnterKeyType = 0x2000,
        ImAnchorRectangle = 0x4000,
        ImInputItemClipRectangle = 0x8000,

        ImPlatformData = 0x80000000,
        ImQueryInput = ImCursorRectangle | ImCursorPosition | ImSurroundingText |
                       ImCurrentSelection | ImAnchorRectangle | ImAnchorPosition,
        ImQueryAll = 0xffffffff
    };
    typedef QFlags<InputMethodQuery> InputMethodQueries;
    constexpr inline QFlags<InputMethodQueries::enum_type> operator|(InputMethodQueries::enum_type f1, InputMethodQueries::enum_type f2) noexcept { return QFlags<InputMethodQueries::enum_type>(f1) | f2; } constexpr inline QFlags<InputMethodQueries::enum_type> operator|(InputMethodQueries::enum_type f1, QFlags<InputMethodQueries::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(InputMethodQueries::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum InputMethodHint {
        ImhNone = 0x0,

        ImhHiddenText = 0x1,
        ImhSensitiveData = 0x2,
        ImhNoAutoUppercase = 0x4,
        ImhPreferNumbers = 0x8,
        ImhPreferUppercase = 0x10,
        ImhPreferLowercase = 0x20,
        ImhNoPredictiveText = 0x40,

        ImhDate = 0x80,
        ImhTime = 0x100,

        ImhPreferLatin = 0x200,

        ImhMultiLine = 0x400,

        ImhNoEditMenu = 0x800,
        ImhNoTextHandles = 0x1000,

        ImhDigitsOnly = 0x10000,
        ImhFormattedNumbersOnly = 0x20000,
        ImhUppercaseOnly = 0x40000,
        ImhLowercaseOnly = 0x80000,
        ImhDialableCharactersOnly = 0x100000,
        ImhEmailCharactersOnly = 0x200000,
        ImhUrlCharactersOnly = 0x400000,
        ImhLatinOnly = 0x800000,

        ImhExclusiveInputMask = 0xffff0000
    };
    typedef QFlags<InputMethodHint> InputMethodHints;
    constexpr inline QFlags<InputMethodHints::enum_type> operator|(InputMethodHints::enum_type f1, InputMethodHints::enum_type f2) noexcept { return QFlags<InputMethodHints::enum_type>(f1) | f2; } constexpr inline QFlags<InputMethodHints::enum_type> operator|(InputMethodHints::enum_type f1, QFlags<InputMethodHints::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(InputMethodHints::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum EnterKeyType {
        EnterKeyDefault,
        EnterKeyReturn,
        EnterKeyDone,
        EnterKeyGo,
        EnterKeySend,
        EnterKeySearch,
        EnterKeyNext,
        EnterKeyPrevious
    };

    enum ToolButtonStyle {
        ToolButtonIconOnly,
        ToolButtonTextOnly,
        ToolButtonTextBesideIcon,
        ToolButtonTextUnderIcon,
        ToolButtonFollowStyle
    };

    enum LayoutDirection {
        LeftToRight,
        RightToLeft,
        LayoutDirectionAuto
    };

    enum AnchorPoint {
        AnchorLeft = 0,
        AnchorHorizontalCenter,
        AnchorRight,
        AnchorTop,
        AnchorVerticalCenter,
        AnchorBottom
    };

    enum FindChildOption {
        FindDirectChildrenOnly = 0x0,
        FindChildrenRecursively = 0x1
    };
    typedef QFlags<FindChildOption> FindChildOptions;

    enum DropAction {
        CopyAction = 0x1,
        MoveAction = 0x2,
        LinkAction = 0x4,
        ActionMask = 0xff,
        TargetMoveAction = 0x8002,
        IgnoreAction = 0x0
    };
    typedef QFlags<DropAction> DropActions;
    constexpr inline QFlags<DropActions::enum_type> operator|(DropActions::enum_type f1, DropActions::enum_type f2) noexcept { return QFlags<DropActions::enum_type>(f1) | f2; } constexpr inline QFlags<DropActions::enum_type> operator|(DropActions::enum_type f1, QFlags<DropActions::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(DropActions::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum CheckState {
        Unchecked,
        PartiallyChecked,
        Checked
    };

    enum ItemDataRole {
        DisplayRole = 0,
        DecorationRole = 1,
        EditRole = 2,
        ToolTipRole = 3,
        StatusTipRole = 4,
        WhatsThisRole = 5,
        
        FontRole = 6,
        TextAlignmentRole = 7,
        BackgroundRole = 8,
        ForegroundRole = 9,



#line 1552 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        CheckStateRole = 10,
        
        AccessibleTextRole = 11,
        AccessibleDescriptionRole = 12,
        
        SizeHintRole = 13,
        InitialSortOrderRole = 14,
        
        DisplayPropertyRole = 27,
        DecorationPropertyRole = 28,
        ToolTipPropertyRole = 29,
        StatusTipPropertyRole = 30,
        WhatsThisPropertyRole = 31,
        
        UserRole = 0x0100
    };

    enum ItemFlag {
        NoItemFlags = 0,
        ItemIsSelectable = 1,
        ItemIsEditable = 2,
        ItemIsDragEnabled = 4,
        ItemIsDropEnabled = 8,
        ItemIsUserCheckable = 16,
        ItemIsEnabled = 32,
        ItemIsAutoTristate = 64,


#line 1581 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        ItemNeverHasChildren = 128,
        ItemIsUserTristate = 256
    };
    typedef QFlags<ItemFlag> ItemFlags;
    constexpr inline QFlags<ItemFlags::enum_type> operator|(ItemFlags::enum_type f1, ItemFlags::enum_type f2) noexcept { return QFlags<ItemFlags::enum_type>(f1) | f2; } constexpr inline QFlags<ItemFlags::enum_type> operator|(ItemFlags::enum_type f1, QFlags<ItemFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(ItemFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum MatchFlag {
        MatchExactly = 0,
        MatchContains = 1,
        MatchStartsWith = 2,
        MatchEndsWith = 3,


#line 1595 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
        MatchWildcard = 5,
        MatchFixedString = 8,
        MatchRegularExpression = 9,
        MatchCaseSensitive = 16,
        MatchWrap = 32,
        MatchRecursive = 64
    };
    typedef QFlags<MatchFlag> MatchFlags;
    constexpr inline QFlags<MatchFlags::enum_type> operator|(MatchFlags::enum_type f1, MatchFlags::enum_type f2) noexcept { return QFlags<MatchFlags::enum_type>(f1) | f2; } constexpr inline QFlags<MatchFlags::enum_type> operator|(MatchFlags::enum_type f1, QFlags<MatchFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(MatchFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    typedef void * HANDLE;


#line 1609 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"

    enum WindowModality {
        NonModal,
        WindowModal,
        ApplicationModal
    };

    enum TextInteractionFlag {
        NoTextInteraction         = 0,
        TextSelectableByMouse     = 1,
        TextSelectableByKeyboard  = 2,
        LinksAccessibleByMouse    = 4,
        LinksAccessibleByKeyboard = 8,
        TextEditable              = 16,

        TextEditorInteraction     = TextSelectableByMouse | TextSelectableByKeyboard | TextEditable,
        TextBrowserInteraction    = TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard
    };
    typedef QFlags<TextInteractionFlag> TextInteractionFlags;
    constexpr inline QFlags<TextInteractionFlags::enum_type> operator|(TextInteractionFlags::enum_type f1, TextInteractionFlags::enum_type f2) noexcept { return QFlags<TextInteractionFlags::enum_type>(f1) | f2; } constexpr inline QFlags<TextInteractionFlags::enum_type> operator|(TextInteractionFlags::enum_type f1, QFlags<TextInteractionFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(TextInteractionFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum EventPriority {
        HighEventPriority = 1,
        NormalEventPriority = 0,
        LowEventPriority = -1
    };

    enum SizeHint {
        MinimumSize,
        PreferredSize,
        MaximumSize,
        MinimumDescent,
        NSizeHints
    };

    enum WindowFrameSection {
        NoSection,
        LeftSection,           
        TopLeftSection,
        TopSection,
        TopRightSection,
        RightSection,
        BottomRightSection,
        BottomSection,
        BottomLeftSection,
        TitleBarArea    
    };


    enum class Initialization {
        Uninitialized
    };
    static constexpr  Initialization Uninitialized = Initialization::Uninitialized;




#line 1667 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"

    enum CoordinateSystem {
        DeviceCoordinates,
        LogicalCoordinates
    };

    enum TouchPointState {
        TouchPointPressed    = 0x01,
        TouchPointMoved      = 0x02,
        TouchPointStationary = 0x04,
        TouchPointReleased   = 0x08
    };
    typedef QFlags<TouchPointState> TouchPointStates;
    constexpr inline QFlags<TouchPointStates::enum_type> operator|(TouchPointStates::enum_type f1, TouchPointStates::enum_type f2) noexcept { return QFlags<TouchPointStates::enum_type>(f1) | f2; } constexpr inline QFlags<TouchPointStates::enum_type> operator|(TouchPointStates::enum_type f1, QFlags<TouchPointStates::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(TouchPointStates::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }


    enum GestureState
    {
        NoGesture,
        GestureStarted  = 1,
        GestureUpdated  = 2,
        GestureFinished = 3,
        GestureCanceled = 4
    };

    enum GestureType
    {
        TapGesture        = 1,
        TapAndHoldGesture = 2,
        PanGesture        = 3,
        PinchGesture      = 4,
        SwipeGesture      = 5,

        CustomGesture     = 0x0100,

        LastGestureType   = ~0u
    };

    enum GestureFlag
    {
        DontStartGestureOnChildren = 0x01,
        ReceivePartialGestures     = 0x02,
        IgnoredGesturesPropagateToParent = 0x04
    };
    typedef QFlags<GestureFlag> GestureFlags;
    constexpr inline QFlags<GestureFlags::enum_type> operator|(GestureFlags::enum_type f1, GestureFlags::enum_type f2) noexcept { return QFlags<GestureFlags::enum_type>(f1) | f2; } constexpr inline QFlags<GestureFlags::enum_type> operator|(GestureFlags::enum_type f1, QFlags<GestureFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(GestureFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum NativeGestureType
    {
        BeginNativeGesture,
        EndNativeGesture,
        PanNativeGesture,
        ZoomNativeGesture,
        SmartZoomNativeGesture,
        RotateNativeGesture,
        SwipeNativeGesture
    };

#line 1726 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"

    enum NavigationMode
    {
        NavigationModeNone,
        NavigationModeKeypadTabOrder,
        NavigationModeKeypadDirectional,
        NavigationModeCursorAuto,
        NavigationModeCursorForceVisible
    };

    enum CursorMoveStyle {
        LogicalMoveStyle,
        VisualMoveStyle
    };

    enum TimerType {
        PreciseTimer,
        CoarseTimer,
        VeryCoarseTimer
    };

    enum ScrollPhase {
        NoScrollPhase = 0,
        ScrollBegin,
        ScrollUpdate,
        ScrollEnd,
        ScrollMomentum
    };

    enum MouseEventSource {
        MouseEventNotSynthesized,
        MouseEventSynthesizedBySystem,
        MouseEventSynthesizedByQt,
        MouseEventSynthesizedByApplication
    };

    enum MouseEventFlag {
        MouseEventCreatedDoubleClick = 0x01,
        MouseEventFlagMask = 0xFF
    };
    typedef QFlags<MouseEventFlag> MouseEventFlags;
    constexpr inline QFlags<MouseEventFlags::enum_type> operator|(MouseEventFlags::enum_type f1, MouseEventFlags::enum_type f2) noexcept { return QFlags<MouseEventFlags::enum_type>(f1) | f2; } constexpr inline QFlags<MouseEventFlags::enum_type> operator|(MouseEventFlags::enum_type f1, QFlags<MouseEventFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(MouseEventFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

    enum ChecksumType {
        ChecksumIso3309,
        ChecksumItuV41
    };

    enum class HighDpiScaleFactorRoundingPolicy {
        Unset,
        Round,
        Ceil,
        Floor,
        RoundPreferFloor,
        PassThrough
    };

    
    enum ReturnByValueConstant { ReturnByValue }; 


    
    inline const QMetaObject *qt_getEnumMetaObject(ScrollBarPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScrollBarPolicy) noexcept { return "ScrollBarPolicy"; }
    inline const QMetaObject *qt_getEnumMetaObject(FocusPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(FocusPolicy) noexcept { return "FocusPolicy"; }
    inline const QMetaObject *qt_getEnumMetaObject(ContextMenuPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ContextMenuPolicy) noexcept { return "ContextMenuPolicy"; }
    inline const QMetaObject *qt_getEnumMetaObject(ArrowType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ArrowType) noexcept { return "ArrowType"; }
    inline const QMetaObject *qt_getEnumMetaObject(ToolButtonStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ToolButtonStyle) noexcept { return "ToolButtonStyle"; }
    inline const QMetaObject *qt_getEnumMetaObject(PenStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(PenStyle) noexcept { return "PenStyle"; }
    inline const QMetaObject *qt_getEnumMetaObject(PenCapStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(PenCapStyle) noexcept { return "PenCapStyle"; }
    inline const QMetaObject *qt_getEnumMetaObject(PenJoinStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(PenJoinStyle) noexcept { return "PenJoinStyle"; }
    inline const QMetaObject *qt_getEnumMetaObject(BrushStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(BrushStyle) noexcept { return "BrushStyle"; }
    inline const QMetaObject *qt_getEnumMetaObject(FillRule) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(FillRule) noexcept { return "FillRule"; }
    inline const QMetaObject *qt_getEnumMetaObject(MaskMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MaskMode) noexcept { return "MaskMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(BGMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(BGMode) noexcept { return "BGMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(ClipOperation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ClipOperation) noexcept { return "ClipOperation"; }
    inline const QMetaObject *qt_getEnumMetaObject(SizeMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SizeMode) noexcept { return "SizeMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(Axis) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Axis) noexcept { return "Axis"; }
    inline const QMetaObject *qt_getEnumMetaObject(Corner) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Corner) noexcept { return "Corner"; }
    inline const QMetaObject *qt_getEnumMetaObject(Edge) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Edge) noexcept { return "Edge"; }
    inline const QMetaObject *qt_getEnumMetaObject(LayoutDirection) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(LayoutDirection) noexcept { return "LayoutDirection"; }
    inline const QMetaObject *qt_getEnumMetaObject(SizeHint) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SizeHint) noexcept { return "SizeHint"; }
    inline const QMetaObject *qt_getEnumMetaObject(Orientation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Orientation) noexcept { return "Orientation"; }
    inline const QMetaObject *qt_getEnumMetaObject(DropAction) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DropAction) noexcept { return "DropAction"; }
    inline const QMetaObject *qt_getEnumMetaObject(Alignment) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Alignment) noexcept { return "Alignment"; }
    inline const QMetaObject *qt_getEnumMetaObject(TextFlag) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextFlag) noexcept { return "TextFlag"; }
    inline const QMetaObject *qt_getEnumMetaObject(Orientations) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Orientations) noexcept { return "Orientations"; }
    inline const QMetaObject *qt_getEnumMetaObject(SplitBehavior) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SplitBehavior) noexcept { return "SplitBehavior"; }
    inline const QMetaObject *qt_getEnumMetaObject(DropActions) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DropActions) noexcept { return "DropActions"; }
    inline const QMetaObject *qt_getEnumMetaObject(Edges) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Edges) noexcept { return "Edges"; }
    inline const QMetaObject *qt_getEnumMetaObject(DockWidgetAreas) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DockWidgetAreas) noexcept { return "DockWidgetAreas"; }
    inline const QMetaObject *qt_getEnumMetaObject(ToolBarAreas) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ToolBarAreas) noexcept { return "ToolBarAreas"; }
    inline const QMetaObject *qt_getEnumMetaObject(DockWidgetArea) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DockWidgetArea) noexcept { return "DockWidgetArea"; }
    inline const QMetaObject *qt_getEnumMetaObject(ToolBarArea) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ToolBarArea) noexcept { return "ToolBarArea"; }
    inline const QMetaObject *qt_getEnumMetaObject(TextFormat) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextFormat) noexcept { return "TextFormat"; }
    inline const QMetaObject *qt_getEnumMetaObject(TextElideMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextElideMode) noexcept { return "TextElideMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(DateFormat) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DateFormat) noexcept { return "DateFormat"; }
    inline const QMetaObject *qt_getEnumMetaObject(TimeSpec) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TimeSpec) noexcept { return "TimeSpec"; }
    inline const QMetaObject *qt_getEnumMetaObject(DayOfWeek) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DayOfWeek) noexcept { return "DayOfWeek"; }
    inline const QMetaObject *qt_getEnumMetaObject(CursorShape) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CursorShape) noexcept { return "CursorShape"; }
    inline const QMetaObject *qt_getEnumMetaObject(GlobalColor) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(GlobalColor) noexcept { return "GlobalColor"; }
    inline const QMetaObject *qt_getEnumMetaObject(AspectRatioMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(AspectRatioMode) noexcept { return "AspectRatioMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(TransformationMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TransformationMode) noexcept { return "TransformationMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(ImageConversionFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ImageConversionFlags) noexcept { return "ImageConversionFlags"; }
    inline const QMetaObject *qt_getEnumMetaObject(Key) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Key) noexcept { return "Key"; }
    inline const QMetaObject *qt_getEnumMetaObject(ShortcutContext) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ShortcutContext) noexcept { return "ShortcutContext"; }
    inline const QMetaObject *qt_getEnumMetaObject(TextInteractionFlag) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextInteractionFlag) noexcept { return "TextInteractionFlag"; }
    inline const QMetaObject *qt_getEnumMetaObject(TextInteractionFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextInteractionFlags) noexcept { return "TextInteractionFlags"; }
    inline const QMetaObject *qt_getEnumMetaObject(ItemSelectionMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemSelectionMode) noexcept { return "ItemSelectionMode"; }
    inline const QMetaObject *qt_getEnumMetaObject(ItemSelectionOperation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemSelectionOperation) noexcept { return "ItemSelectionOperation"; }
    inline const QMetaObject *qt_getEnumMetaObject(ItemFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemFlags) noexcept { return "ItemFlags"; }
    inline const QMetaObject *qt_getEnumMetaObject(CheckState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CheckState) noexcept { return "CheckState"; }
    inline const QMetaObject *qt_getEnumMetaObject(ItemDataRole) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemDataRole) noexcept { return "ItemDataRole"; }
    inline const QMetaObject *qt_getEnumMetaObject(SortOrder) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SortOrder) noexcept { return "SortOrder"; }
    inline const QMetaObject *qt_getEnumMetaObject(CaseSensitivity) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CaseSensitivity) noexcept { return "CaseSensitivity"; }
    inline const QMetaObject *qt_getEnumMetaObject(MatchFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MatchFlags) noexcept { return "MatchFlags"; }
    inline const QMetaObject *qt_getEnumMetaObject(KeyboardModifiers) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(KeyboardModifiers) noexcept { return "KeyboardModifiers"; }
    inline const QMetaObject *qt_getEnumMetaObject(MouseButtons) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MouseButtons) noexcept { return "MouseButtons"; }
    inline const QMetaObject *qt_getEnumMetaObject(WindowType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowType) noexcept { return "WindowType"; }
    inline const QMetaObject *qt_getEnumMetaObject(WindowState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowState) noexcept { return "WindowState"; }
    inline const QMetaObject *qt_getEnumMetaObject(WindowModality) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowModality) noexcept { return "WindowModality"; }
    inline const QMetaObject *qt_getEnumMetaObject(WidgetAttribute) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WidgetAttribute) noexcept { return "WidgetAttribute"; }
    inline const QMetaObject *qt_getEnumMetaObject(ApplicationAttribute) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ApplicationAttribute) noexcept { return "ApplicationAttribute"; }
    inline const QMetaObject *qt_getEnumMetaObject(WindowFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowFlags) noexcept { return "WindowFlags"; }
    inline const QMetaObject *qt_getEnumMetaObject(WindowStates) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowStates) noexcept { return "WindowStates"; }
    inline const QMetaObject *qt_getEnumMetaObject(FocusReason) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(FocusReason) noexcept { return "FocusReason"; }
    inline const QMetaObject *qt_getEnumMetaObject(InputMethodHint) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodHint) noexcept { return "InputMethodHint"; }
    inline const QMetaObject *qt_getEnumMetaObject(InputMethodQuery) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodQuery) noexcept { return "InputMethodQuery"; }
    inline const QMetaObject *qt_getEnumMetaObject(InputMethodHints) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodHints) noexcept { return "InputMethodHints"; }
    inline const QMetaObject *qt_getEnumMetaObject(EnterKeyType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(EnterKeyType) noexcept { return "EnterKeyType"; }
    inline const QMetaObject *qt_getEnumMetaObject(InputMethodQueries) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodQueries) noexcept { return "InputMethodQueries"; }
    inline const QMetaObject *qt_getEnumMetaObject(TouchPointStates) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TouchPointStates) noexcept { return "TouchPointStates"; }
    inline const QMetaObject *qt_getEnumMetaObject(ScreenOrientation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScreenOrientation) noexcept { return "ScreenOrientation"; }
    inline const QMetaObject *qt_getEnumMetaObject(ScreenOrientations) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScreenOrientations) noexcept { return "ScreenOrientations"; }
    inline const QMetaObject *qt_getEnumMetaObject(ConnectionType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ConnectionType) noexcept { return "ConnectionType"; }
    inline const QMetaObject *qt_getEnumMetaObject(ApplicationState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ApplicationState) noexcept { return "ApplicationState"; }

    inline const QMetaObject *qt_getEnumMetaObject(GestureState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(GestureState) noexcept { return "GestureState"; }
    inline const QMetaObject *qt_getEnumMetaObject(GestureType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(GestureType) noexcept { return "GestureType"; }
    inline const QMetaObject *qt_getEnumMetaObject(NativeGestureType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(NativeGestureType) noexcept { return "NativeGestureType"; }
#line 1866 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
    inline const QMetaObject *qt_getEnumMetaObject(CursorMoveStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CursorMoveStyle) noexcept { return "CursorMoveStyle"; }
    inline const QMetaObject *qt_getEnumMetaObject(TimerType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TimerType) noexcept { return "TimerType"; }
    inline const QMetaObject *qt_getEnumMetaObject(ScrollPhase) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScrollPhase) noexcept { return "ScrollPhase"; }
    inline const QMetaObject *qt_getEnumMetaObject(MouseEventSource) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MouseEventSource) noexcept { return "MouseEventSource"; }
    inline const QMetaObject *qt_getEnumMetaObject(MouseEventFlag) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MouseEventFlag) noexcept { return "MouseEventFlag"; }
    inline const QMetaObject *qt_getEnumMetaObject(ChecksumType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ChecksumType) noexcept { return "ChecksumType"; }
    inline const QMetaObject *qt_getEnumMetaObject(HighDpiScaleFactorRoundingPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(HighDpiScaleFactorRoundingPolicy) noexcept { return "HighDpiScaleFactorRoundingPolicy"; }
    inline const QMetaObject *qt_getEnumMetaObject(TabFocusBehavior) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TabFocusBehavior) noexcept { return "TabFocusBehavior"; }
#line 1875 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"

}







typedef bool (*qInternalCallback)(void **);

class __declspec(dllimport) QInternal {
public:
    enum PaintDeviceFlags {
        UnknownDevice = 0x00,
        Widget        = 0x01,
        Pixmap        = 0x02,
        Image         = 0x03,
        Printer       = 0x04,
        Picture       = 0x05,
        Pbuffer       = 0x06,    
        FramebufferObject = 0x07, 
        CustomRaster  = 0x08,
        MacQuartz     = 0x09,
        PaintBuffer   = 0x0a,
        OpenGL        = 0x0b
    };
    enum RelayoutType {
        RelayoutNormal,
        RelayoutDragging,
        RelayoutDropped
    };

    enum DockPosition {
        LeftDock,
        RightDock,
        TopDock,
        BottomDock,
        DockCount
    };

    enum Callback {
        EventNotifyCallback,
        LastCallback
    };
    static bool registerCallback(Callback, qInternalCallback);
    static bool unregisterCallback(Callback, qInternalCallback);
    static bool activateCallbacks(Callback, void **);
};



#line 1928 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qnamespace.h"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h"















































struct __declspec(dllimport) QArrayData
{
    QtPrivate::RefCount ref;
    int size;
    uint alloc : 31;
    uint capacityReserved : 1;

    qptrdiff offset; 

    void *data()
    {
        ((size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)) ? static_cast<void>(0) : qt_assert("size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h", 59));
        const quintptr self = reinterpret_cast<qintptr>(this);
        return reinterpret_cast<void *>(self + offset);
    }

    const void *data() const
    {
        ((size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)) ? static_cast<void>(0) : qt_assert("size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h", 66));
        const quintptr self = reinterpret_cast<qintptr>(this);
        return reinterpret_cast<const void *>(self + offset);
    }

    
    
    
    bool isMutable() const
    {
        return alloc != 0;
    }

    enum AllocationOption {
        CapacityReserved    = 0x1,

        Unsharable          = 0x2,
#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h"
        RawData             = 0x4,
        Grow                = 0x8,

        Default = 0
    };

    typedef QFlags<AllocationOption> AllocationOptions;

    size_t detachCapacity(size_t newSize) const
    {
        if (capacityReserved && newSize < alloc)
            return alloc;
        return newSize;
    }

    AllocationOptions detachFlags() const
    {
        AllocationOptions result;
        if (capacityReserved)
            result |= CapacityReserved;
        return result;
    }

    AllocationOptions cloneFlags() const
    {
        AllocationOptions result;
        if (capacityReserved)
            result |= CapacityReserved;
        return result;
    }

    [[nodiscard]] static QArrayData *allocate(size_t objectSize, size_t alignment,
            size_t capacity, AllocationOptions options = Default) noexcept;
    [[nodiscard]] static QArrayData *reallocateUnaligned(QArrayData *data, size_t objectSize,
            size_t newCapacity, AllocationOptions newOptions = Default) noexcept;
    static void deallocate(QArrayData *data, size_t objectSize,
            size_t alignment) noexcept;

    static const QArrayData shared_null[2];
    static QArrayData *sharedNull() noexcept { return const_cast<QArrayData*>(shared_null); }
};

constexpr inline QFlags<QArrayData::AllocationOptions::enum_type> operator|(QArrayData::AllocationOptions::enum_type f1, QArrayData::AllocationOptions::enum_type f2) noexcept { return QFlags<QArrayData::AllocationOptions::enum_type>(f1) | f2; } constexpr inline QFlags<QArrayData::AllocationOptions::enum_type> operator|(QArrayData::AllocationOptions::enum_type f1, QFlags<QArrayData::AllocationOptions::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QArrayData::AllocationOptions::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

template <class T>
struct QTypedArrayData
    : QArrayData
{

    class iterator {
    public:
        T *i;
        typedef std::random_access_iterator_tag  iterator_category;
        typedef int difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline iterator() : i(nullptr) {}
        inline iterator(T *n) : i(n) {}
        inline iterator(const iterator &o): i(o.i){} 
        inline T &operator*() const { return *i; }
        inline T *operator->() const { return i; }
        inline T &operator[](int j) const { return *(i + j); }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }
        inline bool operator<(const iterator& other) const { return i < other.i; }
        inline bool operator<=(const iterator& other) const { return i <= other.i; }
        inline bool operator>(const iterator& other) const { return i > other.i; }
        inline bool operator>=(const iterator& other) const { return i >= other.i; }
        inline iterator &operator++() { ++i; return *this; }
        inline iterator operator++(int) { T *n = i; ++i; return n; }
        inline iterator &operator--() { i--; return *this; }
        inline iterator operator--(int) { T *n = i; i--; return n; }
        inline iterator &operator+=(int j) { i+=j; return *this; }
        inline iterator &operator-=(int j) { i-=j; return *this; }
        inline iterator operator+(int j) const { return iterator(i+j); }
        inline iterator operator-(int j) const { return iterator(i-j); }
        friend inline iterator operator+(int j, iterator k) { return k + j; }
        inline int operator-(iterator j) const { return i - j.i; }
        inline operator T*() const { return i; }
    };
    friend class iterator;

    class const_iterator {
    public:
        const T *i;
        typedef std::random_access_iterator_tag  iterator_category;
        typedef int difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline const_iterator() : i(nullptr) {}
        inline const_iterator(const T *n) : i(n) {}
        inline const_iterator(const const_iterator &o): i(o.i) {} 
        inline explicit const_iterator(const iterator &o): i(o.i) {}
        inline const T &operator*() const { return *i; }
        inline const T *operator->() const { return i; }
        inline const T &operator[](int j) const { return *(i + j); }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
        inline bool operator<(const const_iterator& other) const { return i < other.i; }
        inline bool operator<=(const const_iterator& other) const { return i <= other.i; }
        inline bool operator>(const const_iterator& other) const { return i > other.i; }
        inline bool operator>=(const const_iterator& other) const { return i >= other.i; }
        inline const_iterator &operator++() { ++i; return *this; }
        inline const_iterator operator++(int) { const T *n = i; ++i; return n; }
        inline const_iterator &operator--() { i--; return *this; }
        inline const_iterator operator--(int) { const T *n = i; i--; return n; }
        inline const_iterator &operator+=(int j) { i+=j; return *this; }
        inline const_iterator &operator-=(int j) { i-=j; return *this; }
        inline const_iterator operator+(int j) const { return const_iterator(i+j); }
        inline const_iterator operator-(int j) const { return const_iterator(i-j); }
        friend inline const_iterator operator+(int j, const_iterator k) { return k + j; }
        inline int operator-(const_iterator j) const { return i - j.i; }
        inline operator const T*() const { return i; }
    };
    friend class const_iterator;



#line 207 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h"

    T *data() { return static_cast<T *>(QArrayData::data()); }
    const T *data() const { return static_cast<const T *>(QArrayData::data()); }

    iterator begin(iterator = iterator()) { return data(); }
    iterator end(iterator = iterator()) { return data() + size; }
    const_iterator begin(const_iterator = const_iterator()) const { return data(); }
    const_iterator end(const_iterator = const_iterator()) const { return data() + size; }
    const_iterator constBegin(const_iterator = const_iterator()) const { return data(); }
    const_iterator constEnd(const_iterator = const_iterator()) const { return data() + size; }

    class AlignmentDummy { QArrayData header; T data; };

    [[nodiscard]] static QTypedArrayData *allocate(size_t capacity,
            AllocationOptions options = Default)
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        return static_cast<QTypedArrayData *>(QArrayData::allocate(sizeof(T),
                    alignof(AlignmentDummy), capacity, options));
    }

    static QTypedArrayData *reallocateUnaligned(QTypedArrayData *data, size_t capacity,
            AllocationOptions options = Default)
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        return static_cast<QTypedArrayData *>(QArrayData::reallocateUnaligned(data, sizeof(T),
                    capacity, options));
    }

    static void deallocate(QArrayData *data)
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        QArrayData::deallocate(data, sizeof(T), alignof(AlignmentDummy));
    }

    static QTypedArrayData *fromRawData(const T *data, size_t n,
            AllocationOptions options = Default)
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        QTypedArrayData *result = allocate(0, options | RawData);
        if (result) {
            ((!result->ref.isShared()) ? static_cast<void>(0) : qt_assert("!result->ref.isShared()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h", 248)); 

            result->offset = reinterpret_cast<const char *>(data)
                - reinterpret_cast<const char *>(result);
            result->size = int(n);
        }
        return result;
    }

    static QTypedArrayData *sharedNull() noexcept
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        return static_cast<QTypedArrayData *>(QArrayData::sharedNull());
    }

    static QTypedArrayData *sharedEmpty()
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        return allocate( 0);
    }


    static QTypedArrayData *unsharableEmpty()
    {
        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
        return allocate( 0, Unsharable);
    }
#line 276 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h"
};

template <class T, size_t N>
struct QStaticArrayData
{
    QArrayData header;
    T data[N];
};


template <class T>
struct QArrayDataPointerRef
{
    QTypedArrayData<T> *ptr;
};







































#line 331 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h"
















namespace QtPrivate {
struct __declspec(dllimport) QContainerImplHelper
{
    enum CutResult { Null, Empty, Full, Subset };
    static CutResult mid(int originalLength, int *position, int *length);
};
}



#line 358 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qarraydata.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"



#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdarg.h"







#pragma once




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

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










} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"







#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 noexcept  {
        
        
        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 suppress this warning, " "or define _REMOVE_FPOS_SEEKPOS to remove std::fpos::seekpos entirely.")]] fpos_t seekpos() const noexcept {
        return {};
    }
#line 76 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"

    [[nodiscard]] streamoff operator-(const fpos& _Right) const noexcept  {
        return static_cast<streamoff>(*this) - static_cast<streamoff>(_Right);
    }

    fpos& operator+=(streamoff _Off) noexcept  { 
        _Myoff += _Off;
        return *this;
    }

    fpos& operator-=(streamoff _Off) noexcept  { 
        _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 noexcept  {
        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) noexcept  {
        return static_cast<streamoff>(_Left) == _Right;
    }




















#line 132 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"

private:
    streamoff _Myoff; 
    fpos_t _Fpos; 
    _Statetype _Mystate; 
};

 using streampos  = fpos<_Mbstatet>;
 using wstreampos = streampos;

 using u8streampos = streampos;
#line 144 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"
 using u16streampos = streampos;
 using u32streampos = streampos;

 extern "C++" 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 159 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"
template <>
struct char_traits<char16_t>;
template <>
struct char_traits<char32_t>;
template <>
struct char_traits<wchar_t>;





 template <class _Ty>
class allocator;
 extern "C++" class ios_base;
 extern "C++" 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;
 extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_streambuf;

#pragma vtordisp(push, 2) 
 extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_istream;
 extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ostream;
#pragma vtordisp(pop) 

 extern "C++" 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;









#line 209 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 225 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"


 extern "C++" template <class _Elem, class _InIt>
class num_get;
 extern "C++" template <class _Elem, class _OutIt>
class num_put;
 template <class _Elem>
class collate;
#line 234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 252 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"





#line 258 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 276 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"





#line 282 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"

}



#pragma warning(pop)
#pragma pack(pop)
#line 290 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"
#line 291 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iosfwd"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"



#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"


namespace pmr {
     class __declspec(novtable) memory_resource {
    public:
        virtual ~memory_resource() noexcept = default;

        [[nodiscard("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] __declspec(allocator) void* allocate(__declspec(guard(overflow)) const size_t _Bytes,
            const size_t _Align = alignof(max_align_t)) { 
            do { if (::std:: _Is_pow_2(_Align)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h", 136, 0, "%s", "memory_resource::allocate(): Alignment must be a power of two.")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"memory_resource::allocate(): Alignment must be a power of two.\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h", 136, 0); } while (false); } ; } while (false);
            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)) {
            
            do { if (::std:: _Is_pow_2(_Align)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h", 143, 0, "%s", "memory_resource::deallocate(): Alignment must be a power of two.")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"memory_resource::deallocate(): Alignment must be a power of two.\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h", 143, 0); } while (false); } ; } while (false);
            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 168 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 ::std:: pmr::_Aligned_get_default_resource();


#line 178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"
    }


    template <class _Uty>
    struct [[nodiscard]] _Deallocate_bytes_guard {
        ~_Deallocate_bytes_guard() noexcept {
            if (_Mem_res) {
                _Mem_res->deallocate(_Pobj, sizeof(_Uty), alignof(_Uty));
            }
        }

        _Deallocate_bytes_guard& operator=(const _Deallocate_bytes_guard&) = delete;
        _Deallocate_bytes_guard& operator=(_Deallocate_bytes_guard&&)      = delete;

        memory_resource* _Mem_res;
        void* _Pobj;
    };
#line 196 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"


     template <class _Ty = byte>


#line 202 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_} { 
            do { if (_Resource) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h", 214, 0, "%s", "Cannot initialize polymorphic_allocator with null resource (N4950 [mem.poly.allocator.ctor]/2)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot initialize polymorphic_allocator with null resource (N4950 [mem.poly.allocator.ctor]/2)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h", 214, 0); } while (false); } ; } while (false);
#line 215 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] __declspec(allocator) _Ty* allocate(__declspec(guard(overflow)) 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("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] __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("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] __declspec(allocator) _Uty* allocate_object(
            __declspec(guard(overflow)) 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("This function allocates memory and returns a raw pointer. " "Discarding the return value will cause a memory leak.")]] __declspec(allocator) _Uty* new_object(_Types&&... _Args) {
            _Uty* const _Ptr = allocate_object<_Uty>();

            _Deallocate_bytes_guard<_Uty> _Guard{_Resource, _Ptr};
            construct(_Ptr, ::std:: forward<_Types>(_Args)...);
            _Guard._Mem_res = nullptr;

            return _Ptr;
        }

        template <class _Uty>
        void delete_object(_Uty* const _Ptr) noexcept  {
            ::std:: _Destroy_in_place(*_Ptr);
            deallocate_object(_Ptr);
        }
#line 277 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"

        template <class _Uty, class... _Types>
        void construct(_Uty* const _Ptr, _Types&&... _Args) {
            

            
            ::std:: apply(
                [_Ptr](auto&&... _Construct_args) {
                    return ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr)))
                        _Uty(::std:: forward<decltype(_Construct_args)>(_Construct_args)...);
                },
                ::std:: uses_allocator_construction_args<_Uty>(*this, ::std:: forward<_Types>(_Args)...));







#line 297 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress this warning.")]] void destroy(_Uty* const _Ptr) noexcept  {
            ::std:: _Destroy_in_place(*_Ptr);
        }

        [[nodiscard]] polymorphic_allocator select_on_container_copy_construction() const noexcept  {
            
            return {};
        }

        [[nodiscard]] memory_resource* resource() const noexcept  {
            
            return _Resource;
        }

        [[nodiscard]] friend bool operator==(
            const polymorphic_allocator& _Lhs, const polymorphic_allocator& _Rhs) noexcept {
            return *_Lhs._Resource == *_Rhs._Resource;
        }






#line 325 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"

    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 344 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"

} 

template <class _Ty, class _Ptr>
struct _Has_no_alloc_destroy<pmr::polymorphic_allocator<_Ty>, _Ptr, void> : true_type {
    
    
};

#line 354 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"

}



#pragma warning(pop)
#pragma pack(pop)
#line 362 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"
#line 363 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xpolymorphic_allocator.h"
#pragma external_header(pop)
#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.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 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"








#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"











#pragma detect_mismatch("annotate_string", "0")
#line 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"

#pragma detect_mismatch("annotate_vector", "0")
#line 64 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"













extern "C" {







}







































#line 126 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"

#line 128 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"



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

#line 135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"
#line 136 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_sanitizer_annotate_container.hpp"
#pragma external_header(pop)
#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 34 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    

    static constexpr _Elem* copy(  _Elem* const _First1,
          const _Elem* const _First2, const size_t _Count) noexcept  {
        


#line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        if (::std:: is_constant_evaluated()) {
            
            for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
                _First1[_Idx] = _First2[_Idx];
            }

            return _First1;
        }
#line 65 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        :: memcpy(_First1, _First2, _Count * sizeof(_Elem));
#line 68 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 76, 0, "%s", "invalid argument")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid argument\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 76, 0); } 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 86 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        :: memmove(_First1, _First2, _Count * sizeof(_Elem));
#line 121 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 173 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 255 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 268 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 282 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 292 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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> {};










#line 356 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 372 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 385 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 397 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        } else
#line 399 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        {
            return __builtin_strlen(_First);
        }


#line 405 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 418 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        } else
#line 420 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        {
            return __builtin_char_memchr(_First, _Ch, _Count);
        }


#line 426 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 436 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 446 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 488 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
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, bool _Special = _Is_specialization_v<_Traits, char_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) noexcept {
    
    if (_Needle_size != 0 && _Start_at < _Hay_size) { 
        if constexpr (_Special) {
            _String_bitmap<typename _Traits::char_type> _Matches;
            if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                    
                return _Traits_find_first_of<_Traits, false>(_Haystack, _Hay_size, _Start_at, _Needle, _Needle_size);
            }

            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); 
                }
            }
        } else {
            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, bool _Special = _Is_specialization_v<_Traits, char_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) noexcept {
    
    if (_Needle_size != 0 && _Hay_size != 0) { 
        if constexpr (_Special) {
            _String_bitmap<typename _Traits::char_type> _Matches;
            if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                    
                return _Traits_find_last_of<_Traits, false>(_Haystack, _Hay_size, _Start_at, _Needle, _Needle_size);
            }

            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; 
                }
            }
        } else {
            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, bool _Special = _Is_specialization_v<_Traits, char_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) noexcept {
    
    if (_Start_at < _Hay_size) { 
        if constexpr (_Special) {
            _String_bitmap<typename _Traits::char_type> _Matches;
            if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                    
                return _Traits_find_first_not_of<_Traits, false>(
                    _Haystack, _Hay_size, _Start_at, _Needle, _Needle_size);
            }

            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); 
                }
            }
        } else {
            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_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, bool _Special = _Is_specialization_v<_Traits, char_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) noexcept {
    
    if (_Hay_size != 0) { 
        if constexpr (_Special) {
            _String_bitmap<typename _Traits::char_type> _Matches;
            if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                    
                return _Traits_find_last_not_of<_Traits, false>(_Haystack, _Hay_size, _Start_at, _Needle, _Needle_size);
            }

            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; 
                }
            }
        } else {
            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_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 _Ty>
inline constexpr bool _Is_EcharT = _Is_any_of_v<_Ty, char, wchar_t,

    char8_t,
#line 895 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    char16_t, char32_t>;


 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 907 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>;


    constexpr _String_view_iterator(const pointer _Data, const size_t _Size, const size_t _Off) noexcept
        : _Mydata(_Data), _Mysize(_Size), _Myoff(_Off) {}


#line 924 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

public:
    [[nodiscard]] constexpr reference operator*() const noexcept {

        do { if (_Mydata) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 928, 0, "%s", "cannot dereference value-initialized string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 928, 0); } while (false); } ; } while (false);
        do { if (_Myoff < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 929, 0, "%s", "cannot dereference end string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 929, 0); } while (false); } ; } while (false);
        return _Mydata[_Myoff];


#line 934 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {

        do { if (_Mydata) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 938, 0, "%s", "cannot dereference value-initialized string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 938, 0); } while (false); } ; } while (false);
        do { if (_Myoff < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 939, 0, "%s", "cannot dereference end string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 939, 0); } while (false); } ; } while (false);
        return _Mydata + _Myoff;


#line 944 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    constexpr _String_view_iterator& operator++() noexcept {

        do { if (_Mydata) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 948, 0, "%s", "cannot increment value-initialized string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 948, 0); } while (false); } ; } while (false);
        do { if (_Myoff < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 949, 0, "%s", "cannot increment string_view iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment string_view iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 949, 0); } while (false); } ; } while (false);
        ++_Myoff;


#line 954 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return *this;
    }

    constexpr _String_view_iterator operator++(int) noexcept {
        _String_view_iterator _Tmp{*this};
        ++*this;
        return _Tmp;
    }

    constexpr _String_view_iterator& operator--() noexcept {

        do { if (_Mydata) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 965, 0, "%s", "cannot decrement value-initialized string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 965, 0); } while (false); } ; } while (false);
        do { if (_Myoff != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 966, 0, "%s", "cannot decrement string_view iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement string_view iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 966, 0); } while (false); } ; } while (false);
        --_Myoff;


#line 971 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        if (_Off != 0) {
            do { if (_Mydata) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 983, 0, "%s", "cannot seek value-initialized string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 983, 0); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Myoff >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 988, 0, "%s", "cannot seek string_view iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string_view iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 988, 0); } while (false); } ; } while (false);
#line 989 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        }

        if (_Off > 0) {
            do { if (_Mysize - _Myoff >= static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 992, 0, "%s", "cannot seek string_view iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string_view iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 992, 0); } while (false); } ; } while (false);
        }


#line 997 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    constexpr _String_view_iterator& operator+=(const difference_type _Off) noexcept {

        _Verify_offset(_Off);
        _Myoff += static_cast<size_t>(_Off);


#line 1006 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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]] friend constexpr _String_view_iterator operator+(
        const difference_type _Off, _String_view_iterator _Right) noexcept {
        _Right += _Off;
        return _Right;
    }

    constexpr _String_view_iterator& operator-=(const difference_type _Off) noexcept {

        if (_Off != 0) {
            do { if (_Mydata) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1025, 0, "%s", "cannot seek value-initialized string_view iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized string_view iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1025, 0); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            do { if (_Myoff >= static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1029, 0, "%s", "cannot seek string_view iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string_view iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1029, 0); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Mysize - _Myoff >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1034, 0, "%s", "cannot seek string_view iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string_view iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1034, 0); } while (false); } ; } while (false);
#line 1035 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        }

        _Myoff -= static_cast<size_t>(_Off);


#line 1041 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (_Mydata == _Right._Mydata && _Mysize == _Right._Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1054, 0, "%s", "cannot subtract incompatible string_view iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot subtract incompatible string_view iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1054, 0); } while (false); } ; } while (false);
#line 1055 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return static_cast<difference_type>(_Myoff - _Right._Myoff);


#line 1059 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (_Mydata == _Right._Mydata && _Mysize == _Right._Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1068, 0, "%s", "cannot compare incompatible string_view iterators for equality")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot compare incompatible string_view iterators for equality\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1068, 0); } while (false); } ; } while (false);
#line 1069 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return _Myoff == _Right._Myoff;


#line 1073 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _String_view_iterator& _Right) const noexcept {

        do { if (_Mydata == _Right._Mydata && _Mysize == _Right._Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1079, 0, "%s", "cannot compare incompatible string_view iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot compare incompatible string_view iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1079, 0); } while (false); } ; } while (false);
#line 1080 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return _Myoff <=> _Right._Myoff;


#line 1084 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }


























#line 1112 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"


    friend constexpr void _Verify_range(const _String_view_iterator& _First, const _String_view_iterator& _Last) {
        do { if (_First._Mydata == _Last._Mydata && _First._Mysize == _Last._Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1116, 0, "%s", "string_view iterators in range are from different views")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string_view iterators in range are from different views\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1116, 0); } while (false); } ; } while (false);
#line 1117 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        do { if (_First._Myoff <= _Last._Myoff) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1117, 0, "%s", "string_view iterator range transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string_view iterator range transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1117, 0); } while (false); } ; } while (false);
    }
#line 1120 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    using _Prevent_inheriting_unwrap = _String_view_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {

        return _Mydata + _Myoff;


#line 1129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    static constexpr bool _Unwrap_when_unverified = 2 == 0;

    constexpr void _Seek_to(pointer _It) noexcept {

        _Myoff = static_cast<size_t>(_It - _Mydata);


#line 1139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

private:

    pointer _Mydata = nullptr;
    size_t _Mysize  = 0;
    size_t _Myoff   = 0;


#line 1149 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
};


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 1163 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

#pragma warning(push)


#pragma warning(disable : 6510)

 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; N4950 [string.view.template.general]/1 "
        "\"The program is ill-formed if traits::char_type is not 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 N4950 "
        "[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)) {}



#line 1206 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string_view(
          const const_pointer _Cts, const size_type _Count) noexcept 
        : _Mydata(_Cts), _Mysize(_Count) {

        do { if (_Count == 0 || _Cts) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1211, 0, "%s", "non-zero size null string_view")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"non-zero size null string_view\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1211, 0); } while (false); } ; } while (false);
#line 1213 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }


    template <contiguous_iterator _Iter, sized_sentinel_for<_Iter> _Sent>
        requires (is_same_v<iter_value_t<_Iter>, _Elem> && !is_convertible_v<_Sent, size_type>)
    constexpr basic_string_view(_Iter _First, _Sent _Last) noexcept(noexcept(_Last - _First)) 
        : _Mydata(::std:: to_address(_First)), _Mysize(static_cast<size_type>(_Last - _First)) {}
















#line 1237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#line 1238 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    [[nodiscard]] constexpr const_iterator begin() const noexcept {

        return const_iterator(_Mydata, _Mysize, 0);


#line 1245 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {

        return const_iterator(_Mydata, _Mysize, _Mysize);


#line 1253 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>(9223372036854775807i64), static_cast<size_t>(-1) / sizeof(_Elem));
    }

    [[nodiscard]] constexpr const_reference operator[](const size_type _Off) const noexcept  {

        do { if (_Off < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1311, 0, "%s", "string_view subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string_view subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1311, 0); } while (false); } ; } while (false);
#line 1313 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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  {

        do { if (_Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1324, 0, "%s", "cannot call front on empty string_view")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot call front on empty string_view\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1324, 0); } while (false); } ; } while (false);
#line 1326 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return _Mydata[0];
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {

        do { if (_Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1331, 0, "%s", "cannot call back on empty string_view")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot call back on empty string_view\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1331, 0); } while (false); } ; } while (false);
#line 1333 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return _Mydata[_Mysize - 1];
    }

    constexpr void remove_prefix(const size_type _Count) noexcept  {

        do { if (_Mysize >= _Count) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1338, 0, "%s", "cannot remove prefix longer than total size")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot remove prefix longer than total size\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1338, 0); } while (false); } ; } while (false);
#line 1340 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        _Mydata += _Count;
        _Mysize -= _Count;
    }

    constexpr void remove_suffix(const size_type _Count) noexcept  {

        do { if (_Mysize >= _Count) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1346, 0, "%s", "cannot remove suffix longer than total size")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot remove suffix longer than total size\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1346, 0); } while (false); } ; } while (false);
#line 1348 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 noexcept  {
        
        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 1451 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"













#line 1465 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }

    [[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);
    }

    [[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));
    }

    [[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);
    }

    [[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);
    }

    [[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));
    }

    [[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);
    }

    [[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);
    }

    [[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));
    }

    [[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);
    }

    [[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);
    }

    [[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));
    }

    [[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;
};

#pragma warning(pop)


template <contiguous_iterator _Iter, sized_sentinel_for<_Iter> _Sent>
basic_string_view(_Iter, _Sent) -> basic_string_view<iter_value_t<_Iter>>;




#line 1639 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1647 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1661 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1759 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>,
        "N4950 [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 1789 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

 using string_view = basic_string_view<char>;

 using u8string_view = basic_string_view<char8_t>;
#line 1794 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
struct hash<basic_string_view<_Elem>> : _Conditionally_enabled_hash<basic_string_view<_Elem>, _Is_EcharT<_Elem>> {
    [[nodiscard]] static size_t _Do_hash(const basic_string_view<_Elem> _Keyval) 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 1827 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1838 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

template <class _Mystr>
class _String_const_iterator : public _Iterator_base {
public:

    using iterator_concept = contiguous_iterator_tag;
#line 1845 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1859, 0, "%s", "cannot dereference value-initialized string iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized string iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1859, 0); } while (false); } ; } while (false);
        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1862, 0, "%s", "cannot dereference string iterator because the iterator was" " invalidated (e.g. reallocation occurred, or the string was destroyed)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference string iterator because the iterator was\" \" invalidated (e.g. reallocation occurred, or the string was destroyed)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1862, 0); } while (false); } ; } while (false);
#line 1863 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        const auto _Contptr = _Mycont->_Myptr();
        const auto _Rawptr  = _Unfancy(_Ptr);
        do { if (_Contptr <= _Rawptr && _Rawptr < _Contptr + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1866, 0, "%s", "cannot dereference string iterator because it is out of range (e.g. an end iterator)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference string iterator because it is out of range (e.g. an end iterator)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1866, 0); } while (false); } ; } while (false);
#line 1867 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#line 1868 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        ;
        return *_Ptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    constexpr _String_const_iterator& operator++() noexcept {

        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1879, 0, "%s", "cannot increment value-initialized string iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized string iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1879, 0); } while (false); } ; } while (false);
        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1882, 0, "%s", "cannot increment string iterator because the iterator was" " invalidated (e.g. reallocation occurred, or the string was destroyed)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment string iterator because the iterator was\" \" invalidated (e.g. reallocation occurred, or the string was destroyed)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1882, 0); } while (false); } ; } while (false);
#line 1883 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        do { if (_Unfancy(_Ptr) < _Mycont->_Myptr() + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1883, 0, "%s", "cannot increment string iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment string iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1883, 0); } while (false); } ; } while (false);
#line 1885 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1898, 0, "%s", "cannot decrement value-initialized string iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized string iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1898, 0); } while (false); } ; } while (false);
        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1901, 0, "%s", "cannot decrement string iterator because the iterator was" " invalidated (e.g. reallocation occurred, or the string was destroyed)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement string iterator because the iterator was\" \" invalidated (e.g. reallocation occurred, or the string was destroyed)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1901, 0); } while (false); } ; } while (false);
#line 1902 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        do { if (_Mycont->_Myptr() < _Unfancy(_Ptr)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1902, 0, "%s", "cannot decrement string iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement string iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1902, 0); } while (false); } ; } while (false);
#line 1904 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        if (_Off == 0) {
            return;
        }

        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1921, 0, "%s", "cannot seek value-initialized string iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized string iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1921, 0); } while (false); } ; } while (false);
        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1924, 0, "%s", "cannot seek string iterator because the iterator was" " invalidated (e.g. reallocation occurred, or the string was destroyed)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string iterator because the iterator was\" \" invalidated (e.g. reallocation occurred, or the string was destroyed)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1924, 0); } while (false); } ; } while (false);
#line 1925 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        const auto _Contptr = _Mycont->_Myptr();
        const auto _Rawptr  = _Unfancy(_Ptr);

        if (_Off < 0) {
            do { if (_Contptr - _Rawptr <= _Off) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1929, 0, "%s", "cannot seek string iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1929, 0); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            using _Size_type = typename _Mystr::size_type;
            const auto _Left = _Mycont->_Mysize - static_cast<_Size_type>(_Rawptr - _Contptr);
            do { if (static_cast<_Size_type>(_Off) <= _Left) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1935, 0, "%s", "cannot seek string iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek string iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 1935, 0); } while (false); } ; } while (false);
        }


#line 1940 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    constexpr _String_const_iterator& operator+=(const difference_type _Off) noexcept {

        _Verify_offset(_Off);
#line 1946 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _String_const_iterator operator+(
        const difference_type _Off, _String_const_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    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 2013 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr void _Compat(const _String_const_iterator& _Right) const noexcept {
        

        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2018, 0, "%s", "string iterators incompatible (e.g." " point to different string instances)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible (e.g.\" \" point to different string instances)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2018, 0); } while (false); } ; } while (false);
#line 2019 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"


#line 2022 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }


    friend constexpr void _Verify_range(
        const _String_const_iterator& _First, const _String_const_iterator& _Last) noexcept {
        do { if (_First._Getcont() == _Last._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2027, 0, "%s", "string iterators in range are from different containers")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators in range are from different containers\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2027, 0); } while (false); } ; } while (false);
        do { if (_First._Ptr <= _Last._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2028, 0, "%s", "string iterator range transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterator range transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2028, 0); } while (false); } ; } while (false);
    }
#line 2031 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
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 {

        const auto _Mycont = static_cast<const _Mystr*>(_Iter._Getcont());
        if (!_Mycont) {
            do { if (!_Iter._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2057, 0, "%s", "cannot convert string iterator to pointer because the iterator was invalidated " "(e.g. reallocation occurred, or the string was destroyed)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot convert string iterator to pointer because the iterator was invalidated \" \"(e.g. reallocation occurred, or the string was destroyed)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2057, 0); } while (false); } ; } while (false);
#line 2058 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        }
#line 2060 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        const auto _Rawptr = ::std:: to_address(_Iter._Ptr);


        if (_Mycont) {
            const auto _Contptr = _Mycont->_Myptr();
            do { if (_Contptr <= _Rawptr && _Rawptr <= _Contptr + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2067, 0, "%s", "cannot convert string iterator to pointer because it is out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot convert string iterator to pointer because it is out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2067, 0); } while (false); } ; } while (false);
#line 2068 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        }
#line 2070 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        return _Rawptr;
    }
};
#line 2075 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2084 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _String_iterator operator+(
        const difference_type _Off, _String_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    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>
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 {

        const auto _Mycont = static_cast<const _Mystr*>(_Iter._Getcont());
        if (!_Mycont) {
            do { if (!_Iter._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2175, 0, "%s", "cannot convert string iterator to pointer because the iterator was invalidated " "(e.g. reallocation occurred, or the string was destroyed)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot convert string iterator to pointer because the iterator was invalidated \" \"(e.g. reallocation occurred, or the string was destroyed)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2175, 0); } while (false); } ; } while (false);
#line 2176 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        }
#line 2178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        const auto _Rawptr = ::std:: to_address(_Iter._Ptr);


        if (_Mycont) {
            const auto _Contptr = _Mycont->_Myptr();
            do { if (_Contptr <= _Rawptr && _Rawptr <= _Contptr + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2185, 0, "%s", "cannot convert string iterator to pointer because it is out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot convert string iterator to pointer because it is out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 2185, 0); } while (false); } ; } while (false);
#line 2186 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        }
#line 2188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        return const_cast<element_type*>(_Rawptr);
    }
};
#line 2193 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer>
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 {
        return _BUF_SIZE <= _Myres;
    }

    constexpr void _Activate_SSO_buffer() noexcept {
        

        if (::std:: is_constant_evaluated()) {
            for (size_type _Idx = 0; _Idx < _BUF_SIZE; ++_Idx) {
                _Bx._Buf[_Idx] = value_type();
            }
        }
#line 2256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    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 : _Buf() {} 
        constexpr ~_Bxty() noexcept {} 

        value_type _Buf[_BUF_SIZE];
        pointer _Ptr;
        char _Alias[_BUF_SIZE]; 
    };
    _Bxty _Bx;

    size_type _Mysize = 0; 
    size_type _Myres  = 0; 
};


template <class _Ty>
inline 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");
}





#line 2320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

 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>>>;

    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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");

    static_assert(is_same_v<_Elem, typename _Traits::char_type>,
        "N4950 [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 N4950 "
        "[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 2394 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"


















































































#line 2477 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

public:
    constexpr
    basic_string() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
        _Tidy_init();
    }

    constexpr explicit basic_string(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
        _Tidy_init();
    }

    constexpr basic_string(const basic_string& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
        _Construct<_Construct_strategy::_From_string>(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    constexpr basic_string(const basic_string& _Right, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct<_Construct_strategy::_From_string>(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    constexpr basic_string(const basic_string& _Right, const size_type _Roff, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Right._Mypair._Myval2._Check_offset(_Roff);
        _Construct<_Construct_strategy::_From_ptr>(
            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, npos));
    }

    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) { 
        _Right._Mypair._Myval2._Check_offset(_Roff);
        _Construct<_Construct_strategy::_From_ptr>(
            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count));
    }












#line 2527 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string(  const _Elem* const _Ptr, __declspec(guard(overflow)) const size_type _Count)
        : _Mypair(_Zero_then_variadic_args_t{}) {
        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Count);
    }

    constexpr basic_string(
          const _Elem* const _Ptr, __declspec(guard(overflow)) const size_type _Count, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Count);
    }

    constexpr basic_string(  const _Elem* const _Ptr) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
    }



#line 2546 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"


    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
#line 2550 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    constexpr basic_string(  const _Elem* const _Ptr, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
    }

    constexpr basic_string(__declspec(guard(overflow)) const size_type _Count, const _Elem _Ch)
        : _Mypair(_Zero_then_variadic_args_t{}) { 
        _Construct<_Construct_strategy::_From_char>(_Ch, _Count);
    }


    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
#line 2563 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    constexpr basic_string(__declspec(guard(overflow)) const size_type _Count, const _Elem _Ch, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Construct<_Construct_strategy::_From_char>(_Ch, _Count);
    }

    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) {
        _Adl_verify_range(_First, _Last);
        auto _UFirst = _Get_unwrapped(_First);
        auto _ULast  = _Get_unwrapped(_Last);
        if (_UFirst == _ULast) {
            _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
            _Tidy_init();
        } else {
            if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
                _Construct<_Construct_strategy::_From_ptr>(
                    _UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
            } else if constexpr (_Is_cpp17_fwd_iter_v<decltype(_UFirst)>) {
                const auto _Length = static_cast<size_t>(::std:: distance(_UFirst, _ULast));
                const auto _Count  = _Convert_size<size_type>(_Length);
                _Construct_from_iter(::std:: move(_UFirst), ::std:: move(_ULast), _Count);
            } else {
                _Construct_from_iter(::std:: move(_UFirst), ::std:: move(_ULast));
            }
        }
    }

private:
    static constexpr void _Start_element_lifetimes(_Elem* const _Ptr, const size_type _Size) {
        
        

        if (::std:: is_constant_evaluated()) {
            for (size_type _Idx = 0; _Idx < _Size; ++_Idx) {
                ::std:: construct_at(_Ptr + _Idx);
            }
        }



#line 2605 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    enum class _Construct_strategy : uint8_t { _From_char, _From_ptr, _From_string };

    template <_Construct_strategy _Strat, class _Char_or_ptr>
    constexpr void _Construct(const _Char_or_ptr _Arg, __declspec(guard(overflow)) const size_type _Count) {
        auto& _My_data = _Mypair._Myval2;
        ;

        if constexpr (_Strat == _Construct_strategy::_From_char) {
            ;
        } else {
            ;
        }

        if (_Count > max_size()) {
            _Xlen_string(); 
        }

        auto& _Al       = _Getal();
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al);
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);

        if (_Count < _BUF_SIZE) {
            _My_data._Mysize = _Count;
            _My_data._Myres  = _BUF_SIZE - 1;

            if constexpr (_Strat == _Construct_strategy::_From_char) {
                _Traits::assign(_My_data._Bx._Buf, _Count, _Arg);
                _Traits::assign(_My_data._Bx._Buf[_Count], _Elem());
            } else if constexpr (_Strat == _Construct_strategy::_From_ptr) {
                _Traits::copy(_My_data._Bx._Buf, _Arg, _Count);
                _Traits::assign(_My_data._Bx._Buf[_Count], _Elem());
            } else { 



                _Traits::copy(_My_data._Bx._Buf, _Arg, _BUF_SIZE);
#line 2644 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
            }

            _Proxy._Release();
            return;
        }

        _My_data._Myres         = _BUF_SIZE - 1;
        size_type _New_capacity = _Calculate_growth(_Count);
        ++_New_capacity;
        const pointer _New_ptr = _Allocate_at_least_helper(_Al, _New_capacity); 
        --_New_capacity;
        _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);

        _Start_element_lifetimes(_Unfancy(_New_ptr), _New_capacity + 1);

        _My_data._Mysize = _Count;
        _My_data._Myres  = _New_capacity;
        if constexpr (_Strat == _Construct_strategy::_From_char) {
            _Traits::assign(_Unfancy(_New_ptr), _Count, _Arg);
            _Traits::assign(_Unfancy(_New_ptr)[_Count], _Elem());
        } else if constexpr (_Strat == _Construct_strategy::_From_ptr) {
            _Traits::copy(_Unfancy(_New_ptr), _Arg, _Count);
            _Traits::assign(_Unfancy(_New_ptr)[_Count], _Elem());
        } else { 
            _Traits::copy(_Unfancy(_New_ptr), _Arg, _Count + 1);
        }

        ;
        _Proxy._Release();
    }

    template <class _Iter, class _Sent, class _Size = nullptr_t>
    constexpr void _Construct_from_iter(_Iter _First, const _Sent _Last, _Size _Count = {}) {
        
        
        
        

        auto& _My_data  = _Mypair._Myval2;
        auto& _Al       = _Getal();
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al);
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);

        _My_data._Mysize = 0;
        _My_data._Myres  = _BUF_SIZE - 1;

        if constexpr (is_same_v<_Size, size_type>) {
            if (_Count > max_size()) {
                _Xlen_string(); 
            }

            if (_Count >= _BUF_SIZE) {
                size_type _New_capacity = _Calculate_growth(_Count);
                ++_New_capacity;
                const pointer _New_ptr = _Allocate_at_least_helper(_Al, _New_capacity); 
                --_New_capacity;
                _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
                _My_data._Myres = _New_capacity;

                _Start_element_lifetimes(_Unfancy(_New_ptr), _New_capacity + 1);
            }
        }

        _Tidy_deallocate_guard<basic_string> _Guard{this};
        for (; _First != _Last; ++_First) {
            if constexpr (!is_same_v<_Size, size_type>) {
                if (_My_data._Mysize == _My_data._Myres) { 
                    if (_My_data._Mysize == max_size()) {
                        _Xlen_string(); 
                    }

                    const auto _Old_ptr     = _My_data._Myptr();
                    size_type _New_capacity = _Calculate_growth(_My_data._Mysize);
                    ++_New_capacity;
                    const pointer _New_ptr = _Allocate_at_least_helper(_Al, _New_capacity); 
                    --_New_capacity;

                    _Start_element_lifetimes(_Unfancy(_New_ptr), _New_capacity + 1);
                    _Traits::copy(_Unfancy(_New_ptr), _Old_ptr, _My_data._Mysize);
                    if (_My_data._Myres >= _BUF_SIZE) { 
                        _Al.deallocate(_My_data._Bx._Ptr, _My_data._Myres + 1);
                        _My_data._Bx._Ptr = _New_ptr;
                    } else {
                        _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
                    }
                    _My_data._Myres = _New_capacity;
                }
            }

            _Elem* const _Ptr = _My_data._Myptr();
            _Traits::assign(_Ptr[_My_data._Mysize], *_First);
            ++_My_data._Mysize;
        }

        _Elem* const _Ptr = _My_data._Myptr();
        _Traits::assign(_Ptr[_My_data._Mysize], _Elem());
        ;
        _Guard._Target = nullptr;
        _Proxy._Release();
    }

public:
















#line 2763 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string(basic_string&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Right._Getal())) {
        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
        _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) {
        if constexpr (!_Alty_traits::is_always_equal::value) {
            if (_Getal() != _Right._Getal()) {
                _Construct<_Construct_strategy::_From_string>(
                    _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
                return;
            }
        }

        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
        _Take_contents(_Right);
    }

    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         = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); 

        if (_New_capacity < _New_size) {
            _New_capacity = _Calculate_growth(_New_size, _BUF_SIZE - 1, max_size());
            ++_New_capacity;
            const pointer _Fancyptr = _Allocate_at_least_helper(_Getal(), _New_capacity); 
            --_New_capacity;
            _Ptr = _Unfancy(_Fancyptr);
            _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);

            _Start_element_lifetimes(_Ptr, _New_capacity + 1);
        }

        _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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal())); 
            _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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal())); 
            _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();
        }

        auto _New_capacity = _Calculate_growth(_New_size, _BUF_SIZE - 1, _Max);
        auto&& _Alproxy    = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); 
        ++_New_capacity;
        const pointer _Fancyptr = _Allocate_at_least_helper(_Getal(), _New_capacity); 
        --_New_capacity;
        
        _Start_element_lifetimes(_Unfancy(_Fancyptr), _New_capacity + 1);
        _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) {
        const basic_string_view<_Elem, _Traits> _As_view = _Right;
        _Construct<_Construct_strategy::_From_ptr>(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
    }

    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) { 
        const basic_string_view<_Elem, _Traits> _As_view = _Right;
        const auto _As_sub_view                          = _As_view.substr(_Roff, _Count);
        _Construct<_Construct_strategy::_From_ptr>(_As_sub_view.data(), _Convert_size<size_type>(_As_sub_view.size()));
    }
#line 2909 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"


    basic_string(_String_constructor_rvalue_allocator_tag, _Alloc&& _Al)
        : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Al)) {
        
        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
        _Tidy_init();
    }

    [[nodiscard]] bool _Move_assign_from_buffer(_Elem* const _Right, const size_type _Size, const size_type _Res) {
        
        auto& _My_data = _Mypair._Myval2;
        ;
        ; 
        _Traits::assign(_Right[_Size], _Elem());

        const bool _Is_large = _Res > _BUF_SIZE; 
        if (_Is_large) {
            ;
            _Construct_in_place(_My_data._Bx._Ptr, _Refancy<pointer>(_Right));
            _My_data._Mysize = _Size;
            _My_data._Myres  = _Res - 1;
            ;
        } else {
            _Traits::copy(_My_data._Bx._Buf, _Right, _Res);
            _My_data._Mysize = _Size;
            _My_data._Myres  = _BUF_SIZE - 1;
        }

        return _Is_large;
    }

    
    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 {
            
            size_type _Allocated = _BUF_SIZE + 1;
            _Result._Ptr         = _Allocate_at_least_helper(_Al, _Allocated);
            _Traits::copy(_Unfancy(_Result._Ptr), _My_data._Bx._Buf, _BUF_SIZE);
            _Result._Res = _Allocated;
        }
        _My_data._Orphan_all();
        _Tidy_init();
        return _Result;
    }
#line 2969 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al), static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Right_al));
            }
        } 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 3027 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
            {

                if (_Right_data._Large_string_engaged()) {
                    
                    _Swap_proxy_and_iterators(_Right);
                } else {
                    _Right_data._Orphan_all();
                }
#line 3036 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

                _Memcpy_val_from(_Right);
                _Right._Tidy_init();
                return;
            }
        }
#line 3043 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        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 { 
            _My_data._Activate_SSO_buffer();
            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
            _Right_data._Orphan_all();
        }

        _My_data._Myres  = _Right_data._Myres;
        _My_data._Mysize = _Right_data._Mysize;

        _Right._Tidy_init();
    }





















#line 3081 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

public:
    constexpr basic_string(initializer_list<_Elem> _Ilist, const _Alloc& _Al = allocator_type())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
        _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) {

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3110, 0, "%s", "string iterator incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterator incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3110, 0); } while (false); } ; } while (false);
#line 3112 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3122, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3122, 0); } while (false); } ; } while (false);
#line 3124 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();

        auto&& _Alproxy          = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
        const auto _To_delete    = _Mypair._Myval2._Myproxy;
        _Mypair._Myval2._Myproxy = nullptr;
        _Delete_plain_internal(_Alproxy, _To_delete);
#line 3137 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    }

    static constexpr auto npos{static_cast<size_type>(-1)};

private:
    constexpr void _Copy_assign_val_from_small(const basic_string& _Right) {
        
        _Tidy_deallocate();

        if constexpr (_Can_memcpy_val) {

            if (!::std:: is_constant_evaluated())
#line 3150 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
            {
                _Memcpy_val_from(_Right);
                return;
            }
        }
#line 3156 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        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       = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al);
                auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Right_al);
                _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;
                    auto _New_capacity       = _Calculate_growth(_New_size, 0, _Right.max_size());
                    auto _Right_al_non_const = _Right_al;
                    ++_New_capacity;
                    const auto _New_ptr = _Allocate_at_least_helper(_Right_al_non_const, _New_capacity); 
                    --_New_capacity;

                    _Start_element_lifetimes(_Unfancy(_New_ptr), _New_capacity + 1);

                    _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 3215 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string& operator=(  const _Elem* const _Ptr) {
        return assign(_Ptr);
    }



#line 3223 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3243 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3279 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string& append(
          const _Elem* const _Ptr, __declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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);
        }
    }












#line 3357 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    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 3385 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string& assign(
          const _Elem* const _Ptr, __declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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);
            }
        }
    }


















#line 3468 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    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 3498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    constexpr basic_string& insert(
        const size_type _Off,   const _Elem* const _Ptr, __declspec(guard(overflow)) 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 3512 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, __declspec(guard(overflow)) 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) { 

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3581, 0, "%s", "string iterator incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterator incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3581, 0); } while (false); } ; } while (false);
#line 3583 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, __declspec(guard(overflow)) const size_type _Count, const _Elem _Ch) {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3592, 0, "%s", "string iterator incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterator incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3592, 0); } while (false); } ; } while (false);
#line 3594 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3603, 0, "%s", "string iterator incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterator incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3603, 0); } while (false); } ; } while (false);
#line 3605 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }



















#line 3638 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    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;
        _Traits::move(_Erase_at, _Erase_at + _Count, _New_size - _Off + 1); 
        ;
        _Mypair._Myval2._Mysize = _New_size;
        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  {

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3667, 0, "%s", "string iterator incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterator incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3667, 0); } while (false); } ; } while (false);
#line 3669 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3678, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3678, 0); } while (false); } ; } while (false);
#line 3680 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3718 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 
            _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);

            const auto _New_size = _Old_size - (_Nx - _Count);
            ;
            _Mypair._Myval2._Mysize = _New_size;
            return *this;
        }

        const size_type _Growth = static_cast<size_type>(_Count - _Nx);

        
        

        if (!::std:: is_constant_evaluated())
#line 3750 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
            
            
            const auto _New_size = _Old_size + _Count - _Nx;
            ;
            _Mypair._Myval2._Mysize = _New_size;
            _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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3835, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3835, 0); } while (false); } ; } while (false);
#line 3837 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3848, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3848, 0); } while (false); } ; } while (false);
#line 3850 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
    }
#line 3854 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3860, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3860, 0); } while (false); } ; } while (false);
#line 3862 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3871, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3871, 0); } while (false); } ; } while (false);
#line 3873 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3882, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3882, 0); } while (false); } ; } while (false);
#line 3884 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        do { if (_First._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3894, 0, "%s", "string iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 3894, 0); } while (false); } ; } while (false);
#line 3896 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
        }
    }



















#line 3928 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    [[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 (!_My_data._Large_string_engaged()) { 
            return;
        }

        if (_My_data._Mysize < _BUF_SIZE) {
            _Become_small();
            return;
        }

        const size_type _Target_capacity = (::std:: min)(_My_data._Mysize | _ALLOC_MASK, max_size());
        if (_Target_capacity < _My_data._Myres) { 
            auto& _Al              = _Getal();
            const pointer _New_ptr = _Al.allocate(_Target_capacity + 1); 
            ;

            _Start_element_lifetimes(_Unfancy(_New_ptr), _Target_capacity + 1);

            _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  {

        do { if (_Off <= _Mypair._Myval2._Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4038, 0, "%s", "string subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4038, 0); } while (false); } ; } while (false);
#line 4040 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        return _Mypair._Myval2._Myptr()[_Off];
    }

    [[nodiscard]] constexpr const_reference operator[](const size_type _Off) const noexcept
     {

        do { if (_Off <= _Mypair._Myval2._Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4046, 0, "%s", "string subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"string subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4046, 0); } while (false); } ; } while (false);
#line 4048 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4057 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

        do { if (_Old_size != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4082, 0, "%s", "invalid to pop_back empty string")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid to pop_back empty string\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4082, 0); } while (false); } ; } while (false);
#line 4084 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        _Eos(_Old_size - 1);
    }

    [[nodiscard]] constexpr reference front() noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4089, 0, "%s", "front() called on empty string")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty string\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4089, 0); } while (false); } ; } while (false);
#line 4091 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        return _Mypair._Myval2._Myptr()[0];
    }

    [[nodiscard]] constexpr const_reference front() const noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4097, 0, "%s", "front() called on empty string")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty string\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4097, 0); } while (false); } ; } while (false);
#line 4099 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        return _Mypair._Myval2._Myptr()[0];
    }

    [[nodiscard]] constexpr reference back() noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4105, 0, "%s", "back() called on empty string")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty string\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4105, 0); } while (false); } ; } while (false);
#line 4107 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4113, 0, "%s", "back() called on empty string")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty string\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4113, 0); } while (false); } ; } while (false);
#line 4115 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4132 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(__declspec(guard(overflow)) 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);
        }
    }























#line 4183 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    [[nodiscard]] constexpr size_type capacity() const noexcept {
        return _Mypair._Myval2._Myres;
    }


    constexpr void reserve(__declspec(guard(overflow)) 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 suppress this warning.")]] void reserve() {
        if (_Mypair._Myval2._Mysize == 0 && _Mypair._Myval2._Large_string_engaged()) {
            _Become_small();
        }
    }





























#line 4239 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    [[nodiscard("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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;
    }

    static constexpr void _Swap_bx_large_with_small(_Scary_val& _Starts_large, _Scary_val& _Starts_small) noexcept {
        
        const pointer _Ptr = _Starts_large._Bx._Ptr;
        _Destroy_in_place(_Starts_large._Bx._Ptr);

        _Starts_large._Activate_SSO_buffer();
        _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) noexcept {
        using ::std:: swap;

        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;

        const bool _My_large    = _My_data._Large_string_engaged();
        const bool _Right_large = _Right_data._Large_string_engaged();


        if constexpr (_Can_memcpy_val) {

            if (!::std:: is_constant_evaluated())
#line 4288 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
            }
        }
#line 4302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

        if (_My_large && _Right_large) { 
            swap(_My_data._Bx._Ptr, _Right_data._Bx._Ptr); 
        } else if (_My_large) { 
            _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, _My_data._Mysize + 1);
            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
            _Traits::copy(_Right_data._Bx._Buf, _Temp_buf, _My_data._Mysize + 1);
        }

        ::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());


            auto& _My_data    = _Mypair._Myval2;
            auto& _Right_data = _Right._Mypair._Myval2;

            if (!_My_data._Large_string_engaged()) {
                _My_data._Orphan_all();
            }

            if (!_Right_data._Large_string_engaged()) {
                _Right_data._Orphan_all();
            }

            _My_data._Swap_proxy_and_iterators(_Right_data);
#line 4338 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4353 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4390 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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()));
    }
#line 4427 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }

    [[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));
    }

    [[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)));
    }

    [[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()));
    }
#line 4466 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }

    [[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));
    }

    [[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)));
    }

    [[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()));
    }
#line 4503 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }

    [[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));
    }

    [[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)));
    }

    [[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()));
    }
#line 4542 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }

    [[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));
    }

    [[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)));
    }

    [[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 4576 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    [[nodiscard]] constexpr basic_string substr(const size_type _Off = 0, const size_type _Count = npos)


#line 4581 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
        const
#line 4583 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
    {
        
        return basic_string{*this, _Off, _Count};
    }






#line 4594 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"

    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 4636 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4705 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"













#line 4719 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
        size_type _New_capacity       = _Calculate_growth(_New_size);
        auto& _Al                     = _Getal();
        ++_New_capacity;
        const pointer _New_ptr = _Allocate_at_least_helper(_Al, _New_capacity); 
        --_New_capacity;

        _Start_element_lifetimes(_Unfancy(_New_ptr), _New_capacity + 1);
        _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;
        size_type _New_capacity       = _Calculate_growth(_New_size);
        auto& _Al                     = _Getal();
        ++_New_capacity;
        const pointer _New_ptr = _Allocate_at_least_helper(_Al, _New_capacity); 
        --_New_capacity;

        _Start_element_lifetimes(_Unfancy(_New_ptr), _New_capacity + 1);
        _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;
    }

    constexpr void _Become_small() {
        
        auto& _My_data = _Mypair._Myval2;
        ;
        ;

        _My_data._Orphan_all();
        ;
        const pointer _Ptr = _My_data._Bx._Ptr;
        auto& _Al          = _Getal();
        _Destroy_in_place(_My_data._Bx._Ptr);
        _My_data._Activate_SSO_buffer();
        _Traits::copy(_My_data._Bx._Buf, _Unfancy(_Ptr), _My_data._Mysize + 1);
        _Al.deallocate(_Ptr, _My_data._Myres + 1);
        _My_data._Myres = _BUF_SIZE - 1;
    }

    constexpr void _Eos(const size_type _New_size) noexcept { 
        ;
        _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;
        _My_data._Myres  = _BUF_SIZE - 1;
        _My_data._Activate_SSO_buffer();

        
        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
    }

    constexpr void _Tidy_deallocate() noexcept { 
        auto& _My_data = _Mypair._Myval2;
        _My_data._Orphan_all();
        if (_My_data._Large_string_engaged()) {
            ;
            const pointer _Ptr = _My_data._Bx._Ptr;
            auto& _Al          = _Getal();
            _Destroy_in_place(_My_data._Bx._Ptr);
            _My_data._Activate_SSO_buffer();
            _Al.deallocate(_Ptr, _My_data._Myres + 1);
        }

        _My_data._Mysize = 0;
        _My_data._Myres  = _BUF_SIZE - 1;
        
        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
    }

public:
    constexpr void _Orphan_all() noexcept { 
        _Mypair._Myval2._Orphan_all();
    }

private:
    constexpr void _Swap_proxy_and_iterators(basic_string& _Right) noexcept {
        _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 4907 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#line 4908 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {

    do { if (::std:: addressof(_Left) != ::std:: addressof(_Right)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4995, 0, "%s", "You cannot concatenate the same moved string to itself. See N4950 [res.on.arguments]/1.3: " "If a function argument is bound to an rvalue reference parameter, the implementation may assume that " "this parameter is a unique reference to this argument, except that the argument passed to " "a move-assignment operator may be a reference to *this ([lib.types.movedfrom]).")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"You cannot concatenate the same moved string to itself. See N4950 [res.on.arguments]/1.3: \" \"If a function argument is bound to an rvalue reference parameter, the implementation may assume that \" \"this parameter is a unique reference to this argument, except that the argument passed to \" \"a move-assignment operator may be a reference to *this ([lib.types.movedfrom]).\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring", 4995, 0); } while (false); } ; } while (false);
#line 4996 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#line 4997 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5141 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Alloc>
struct hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>>
    : _Conditionally_enabled_hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>, _Is_EcharT<_Elem>> {
    [[nodiscard]] static size_t _Do_hash(const basic_string<_Elem, char_traits<_Elem>, _Alloc>& _Keyval) 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 {
         [[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 5222 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5246 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 5256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
     using u16string = basic_string<char16_t>;
     using u32string = basic_string<char32_t>;
     using wstring   = basic_string<wchar_t>;
} 
#line 5261 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
}








#pragma warning(pop)
#pragma pack(pop)
#line 5273 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#line 5274 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xstring"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string"



#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cctype"





#pragma once





#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {









  __declspec(dllimport) int __cdecl _isctype(  int _C,   int _Type);
  __declspec(dllimport) int __cdecl _isctype_l(  int _C,   int _Type,   _locale_t _Locale);
   __declspec(dllimport) int __cdecl isalpha(  int _C);
  __declspec(dllimport) int __cdecl _isalpha_l(  int _C,   _locale_t _Locale);
   __declspec(dllimport) int __cdecl isupper(  int _C);
  __declspec(dllimport) int __cdecl _isupper_l(  int _C,   _locale_t _Locale);
   __declspec(dllimport) int __cdecl islower(  int _C);
  __declspec(dllimport) int __cdecl _islower_l(  int _C,   _locale_t _Locale);


   __declspec(dllimport) int __cdecl isdigit(  int _C);

  __declspec(dllimport) int __cdecl _isdigit_l(  int _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl isxdigit(  int _C);
  __declspec(dllimport) int __cdecl _isxdigit_l(  int _C,   _locale_t _Locale);


   __declspec(dllimport) int __cdecl isspace(  int _C);

  __declspec(dllimport) int __cdecl _isspace_l(  int _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl ispunct(  int _C);
  __declspec(dllimport) int __cdecl _ispunct_l(  int _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl isblank(  int _C);
  __declspec(dllimport) int __cdecl _isblank_l(  int _C,   _locale_t _Locale);
   __declspec(dllimport) int __cdecl isalnum(  int _C);
  __declspec(dllimport) int __cdecl _isalnum_l(  int _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl isprint(  int _C);
  __declspec(dllimport) int __cdecl _isprint_l(  int _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl isgraph(  int _C);
  __declspec(dllimport) int __cdecl _isgraph_l(  int _C,   _locale_t _Locale);
  __declspec(dllimport) int __cdecl iscntrl(  int _C);
  __declspec(dllimport) int __cdecl _iscntrl_l(  int _C,   _locale_t _Locale);


   __declspec(dllimport) int __cdecl toupper(  int _C);


   __declspec(dllimport) int __cdecl tolower(  int _C);

   __declspec(dllimport) int __cdecl _tolower(  int _C);
  __declspec(dllimport) int __cdecl _tolower_l(  int _C,   _locale_t _Locale);
   __declspec(dllimport) int __cdecl _toupper(  int _C);
  __declspec(dllimport) int __cdecl _toupper_l(  int _C,   _locale_t _Locale);

  __declspec(dllimport) int __cdecl __isascii(  int _C);
  __declspec(dllimport) int __cdecl __toascii(  int _C);
  __declspec(dllimport) int __cdecl __iscsymf(  int _C);
  __declspec(dllimport) 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;
}



    
    
    




















    
    
    
        __declspec(dllimport) int __cdecl _chvalidator(  int _Ch,   int _Mask);
        
    


#line 138 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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 190 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"



    












#line 207 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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;
    }

    
    __declspec(dllimport) int __cdecl _chvalidator_l(  _locale_t,   int _Ch,   int _Mask);
    #line 217 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"

    __inline int __cdecl _chvalidchk_l(
              int       const _C,
              int       const _Mask,
          _locale_t const _Locale
        )
    {
        
        return _chvalidator_l(_Locale, _C, _Mask);
        






#line 234 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"
    }

    
    

    __inline int __cdecl _ischartype_l(
              int       const _C,
              int       const _Mask,
          _locale_t const _Locale
        )
    {
        if (!_Locale)
        {
            return _chvalidchk_l(_C, _Mask, 0);
        }

        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; 
    }

    
    
    
    
    
    
    
    
    
    
    
    

    
    

    
    


    
    
    
    
    

    
    
    
    

#line 295 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"



    
    
    
    
#line 303 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"



#line 307 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"
} __pragma(pack(pop))

#pragma warning(pop) 
#line 311 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\ctype.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cctype"
#line 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cctype"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string"

#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 ::std:: getline(::std:: move(_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 ::std:: 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 ::std:: 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");


    auto _UVal_trunc = _UVal;
















#line 465 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 588 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string"
#line 589 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string"
#pragma external_header(pop)
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    using _Prevent_inheriting_unwrap = move_sentinel;

    
    [[nodiscard]] constexpr move_sentinel<_Unwrapped_t<const _Se&>> _Unwrapped() const&
        noexcept(noexcept(move_sentinel<_Unwrapped_t<const _Se&>>{_Last._Unwrapped()}))
        requires ::std::ranges:: _Weakly_unwrappable_sentinel<_Se> {
        
        return move_sentinel<_Unwrapped_t<const _Se&>>{_Last._Unwrapped()};
    }
    
    [[nodiscard]] constexpr move_sentinel<_Unwrapped_t<_Se>> _Unwrapped() &&
        noexcept(noexcept(move_sentinel<_Unwrapped_t<_Se>>{::std:: move(_Last)._Unwrapped()}))
        requires ::std::ranges:: _Weakly_unwrappable_sentinel<_Se> {
        
        return move_sentinel<_Unwrapped_t<_Se>>{::std:: move(_Last)._Unwrapped()};
    }

private:
    _Se _Last{};
};
#line 235 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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. "
        "(N4950 [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 258 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

    istream_iterator(istream_type& _Istr) : _Myistr(::std:: addressof(_Istr)) {
        _Getval();
    }

    [[nodiscard]] const _Ty& operator*() const noexcept  {
        do { if (_Myistr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 264, 0, "%s", "The stored stream pointer in_stream must be non-null")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"The stored stream pointer in_stream must be non-null\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 264, 0); } while (false); } ; } while (false);
        return _Myval;
    }

    [[nodiscard]] const _Ty* operator->() const noexcept  {
        do { if (_Myistr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 269, 0, "%s", "The stored stream pointer in_stream must be non-null")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"The stored stream pointer in_stream must be non-null\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 269, 0); } while (false); } ; } while (false);
        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 293 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

private:
    void _Getval() { 
        do { if (_Myistr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 296, 0, "%s", "The stored stream pointer in_stream must be non-null")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"The stored stream pointer in_stream must be non-null\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 296, 0); } while (false); } ; } while (false);
        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 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 330 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 383 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();
        }


        do { if (_Strbuf) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 414, 0, "%s", "istreambuf_iterator is not dereferenceable")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"istreambuf_iterator is not dereferenceable\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 414, 0); } while (false); } ; } while (false);
#line 416 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

        return _Val;
    }

    istreambuf_iterator& operator++() {

        do { if (_Strbuf) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 422, 0, "%s", "istreambuf_iterator is not incrementable")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"istreambuf_iterator is not incrementable\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 422, 0); } while (false); } ; } while (false);
#line 424 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 460 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 501 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 512 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_first, _Holds_second };

struct _Variantish_empty_tag {
    explicit _Variantish_empty_tag() = default;
};

template <class _Ty1, class _Ty2>
class _Variantish {
public:
    constexpr explicit _Variantish(_Variantish_empty_tag) noexcept : _Contains{_Variantish_state::_Nothing} {}

    constexpr _Variantish() noexcept(is_nothrow_default_constructible_v<_Ty1>)
        requires default_initializable<_Ty1>
        : _First{}, _Contains{_Variantish_state::_Holds_first} {}

    template <class... _Types>
    constexpr explicit _Variantish(in_place_type_t<_Ty1>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty1, _Types...>)
        : _First(::std:: forward<_Types>(_Args)...), _Contains{_Variantish_state::_Holds_first} {}

    template <class... _Types>
        requires _Different_from<_Ty1, _Ty2>
    constexpr explicit _Variantish(in_place_type_t<_Ty2>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty2, _Types...>)
        : _Second(::std:: forward<_Types>(_Args)...), _Contains{_Variantish_state::_Holds_second} {}

    
    template <class _Uty1, class _Uty2>
        requires _Different_from<_Variantish<_Uty1, _Uty2>, _Variantish>
    constexpr _Variantish(const _Variantish<_Uty1, _Uty2>& _That) noexcept(
        is_nothrow_constructible_v<_Ty1, const _Uty1&> && is_nothrow_constructible_v<_Ty2, const _Uty2&>)
        : _Contains{_That._Contains} {
        
        switch (_That._Contains) {
        case _Variantish_state::_Holds_first:
            ::std:: _Construct_in_place(_First, _That._Get_first());
            break;
        case _Variantish_state::_Holds_second:
            ::std:: _Construct_in_place(_Second, _That._Get_second());
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    
    constexpr _Variantish(const _Variantish&) requires is_trivially_copy_constructible_v<_Ty1>
        && is_trivially_copy_constructible_v<_Ty2> = default;
    

    constexpr _Variantish(const _Variantish& _That) noexcept(
        is_nothrow_copy_constructible_v<_Ty1>&& is_nothrow_copy_constructible_v<_Ty2>)
        : _Contains{_That._Contains} {
        switch (_Contains) {
        case _Variantish_state::_Holds_first:
            ::std:: _Construct_in_place(_First, _That._Get_first());
            break;
        case _Variantish_state::_Holds_second:
            ::std:: _Construct_in_place(_Second, _That._Get_second());
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    
    constexpr _Variantish(_Variantish&&) requires is_trivially_move_constructible_v<_Ty1>
        && is_trivially_move_constructible_v<_Ty2> = default;
    

    constexpr _Variantish(_Variantish&& _That) noexcept(
        is_nothrow_move_constructible_v<_Ty1>&& is_nothrow_move_constructible_v<_Ty2>)
        : _Contains{_That._Contains} {
        switch (_Contains) {
        case _Variantish_state::_Holds_first:
            ::std:: _Construct_in_place(_First, ::std:: move(_That._Get_first()));
            break;
        case _Variantish_state::_Holds_second:
            ::std:: _Construct_in_place(_Second, ::std:: move(_That._Get_second()));
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    constexpr ~_Variantish() {
        _Raw_clear();
    }

    
    constexpr ~_Variantish() requires is_trivially_destructible_v<_Ty1> && is_trivially_destructible_v<_Ty2> = default;

    constexpr _Variantish& operator=(const _Variantish&) requires is_trivially_destructible_v<_Ty1>
        && is_trivially_destructible_v<_Ty2>
        && is_trivially_copy_constructible_v<_Ty1>
        && is_trivially_copy_constructible_v<_Ty2>
        && is_trivially_copy_assignable_v<_Ty1>
        && is_trivially_copy_assignable_v<_Ty2> = default;
    

    constexpr _Variantish& operator=(const _Variantish& _That) noexcept(
        is_nothrow_copy_constructible_v<_Ty1>&& is_nothrow_copy_constructible_v<_Ty2>&&
            is_nothrow_copy_assignable_v<_Ty1>&& is_nothrow_copy_assignable_v<_Ty2>) {
        if (_Contains == _That._Contains) {
            switch (_Contains) {
            case _Variantish_state::_Holds_first:
                _Get_first() = _That._Get_first();
                break;
            case _Variantish_state::_Holds_second:
                _Get_second() = _That._Get_second();
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return *this;
        }

        _Clear();

        switch (_That._Contains) {
        case _Variantish_state::_Holds_first:
            ::std:: _Construct_in_place(_First, _That._Get_first());
            break;
        case _Variantish_state::_Holds_second:
            ::std:: _Construct_in_place(_Second, _That._Get_second());
            break;
        case _Variantish_state::_Nothing:
            break;
        }

        _Contains = _That._Contains;

        return *this;
    }

    
    constexpr _Variantish& operator=(_Variantish&&) requires is_trivially_destructible_v<_Ty1>
        && is_trivially_destructible_v<_Ty2>
        && is_trivially_move_constructible_v<_Ty1>
        && is_trivially_move_constructible_v<_Ty2>
        && is_trivially_move_assignable_v<_Ty1>
        && is_trivially_move_assignable_v<_Ty2> = default;
    

    constexpr _Variantish& operator=(_Variantish&& _That) noexcept(
        is_nothrow_move_constructible_v<_Ty1>&& is_nothrow_move_constructible_v<_Ty2>&&
            is_nothrow_move_assignable_v<_Ty1>&& is_nothrow_move_assignable_v<_Ty2>) {
        if (_Contains == _That._Contains) {
            switch (_Contains) {
            case _Variantish_state::_Holds_first:
                _Get_first() = ::std:: move(_That._Get_first());
                break;
            case _Variantish_state::_Holds_second:
                _Get_second() = ::std:: move(_That._Get_second());
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return *this;
        }

        _Clear();

        switch (_That._Contains) {
        case _Variantish_state::_Holds_first:
            ::std:: _Construct_in_place(_First, ::std:: move(_That._Get_first()));
            break;
        case _Variantish_state::_Holds_second:
            ::std:: _Construct_in_place(_Second, ::std:: move(_That._Get_second()));
            break;
        case _Variantish_state::_Nothing:
            break;
        }

        _Contains = _That._Contains;

        return *this;
    }

    
    template <class _Uty1, class _Uty2>
        requires _Different_from<_Variantish<_Uty1, _Uty2>, _Variantish>
    constexpr _Variantish& operator=(const _Variantish<_Uty1, _Uty2>& _That) noexcept(
        is_nothrow_constructible_v<_Ty1, const _Uty1&> && is_nothrow_constructible_v<_Ty2, const _Uty2&>
            && is_nothrow_assignable_v<_Ty1&, const _Uty1&> && is_nothrow_assignable_v<_Ty2&, const _Uty2&>) {
        
        if (_Contains == _That._Contains) {
            switch (_Contains) {
            case _Variantish_state::_Holds_first:
                _Get_first() = _That._Get_first();
                break;
            case _Variantish_state::_Holds_second:
                _Get_second() = _That._Get_second();
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return *this;
        }

        _Clear();

        switch (_That._Contains) {
        case _Variantish_state::_Holds_first:
            ::std:: _Construct_in_place(_First, _That._Get_first());
            break;
        case _Variantish_state::_Holds_second:
            ::std:: _Construct_in_place(_Second, _That._Get_second());
            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<_Ty1> && is_nothrow_move_constructible_v<_Ty2>
            && is_nothrow_swappable_v<_Ty1> && is_nothrow_swappable_v<_Ty2>)
        requires (!_Is_trivially_swappable_v<_Ty1> || !_Is_trivially_swappable_v<_Ty2>) {
        
        if (_Left._Contains == _Right._Contains) {
            switch (_Left._Contains) {
            case _Variantish_state::_Holds_first:
                ::std::ranges:: swap(_Left._Get_first(), _Right._Get_first());
                break;
            case _Variantish_state::_Holds_second:
                ::std::ranges:: swap(_Left._Get_second(), _Right._Get_second());
                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_first:
            _First.~_Ty1();
            break;
        case _Variantish_state::_Holds_second:
            _Second.~_Ty2();
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    [[nodiscard]] constexpr _Ty1& _Get_first() noexcept {
        return _First;
    }
    [[nodiscard]] constexpr const _Ty1& _Get_first() const noexcept {
        return _First;
    }

    [[nodiscard]] constexpr _Ty2& _Get_second() noexcept {
        return _Second;
    }
    [[nodiscard]] constexpr const _Ty2& _Get_second() const noexcept {
        return _Second;
    }

    constexpr void _Clear() noexcept {
        _Raw_clear();
        _Contains = _Variantish_state::_Nothing;
    }

    template <class... _Types>
    constexpr void _Emplace_first(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty1, _Types...>) {
        _Clear();

        ::std:: _Construct_in_place(_First, ::std:: forward<_Types>(_Args)...);
        _Contains = _Variantish_state::_Holds_first;
    }

    template <class... _Types>
    constexpr void _Emplace_second(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty2, _Types...>) {
        _Clear();

        ::std:: _Construct_in_place(_Second, ::std:: forward<_Types>(_Args)...);
        _Contains = _Variantish_state::_Holds_second;
    }

    union {
        remove_cv_t<_Ty1> _First;
        remove_cv_t<_Ty2> _Second;
    };

    _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(_Variantish_empty_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*() {

        do { if (_Val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 911, 0, "%s", "common_iterator can only be dereferenced if it holds an iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"common_iterator can only be dereferenced if it holds an iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 911, 0); } while (false); } ; } while (false);
#line 912 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 913 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return *_Val._Get_first();
    }

    [[nodiscard]] constexpr decltype(auto) operator*() const
        requires _Dereferenceable<const _Iter>
    {

        do { if (_Val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 921, 0, "%s", "common_iterator can only be dereferenced if it holds an iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"common_iterator can only be dereferenced if it holds an iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 921, 0); } while (false); } ; } while (false);
#line 922 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 923 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return *_Val._Get_first();
    }

    
    [[nodiscard]] constexpr 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>>) {
        

        do { if (_Val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 934, 0, "%s", "common_iterator can only be dereferenced if it holds an iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"common_iterator can only be dereferenced if it holds an iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 934, 0); } while (false); } ; } while (false);
#line 935 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 936 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        if constexpr (_Has_member_arrow<const _Iter&> || is_pointer_v<_Iter>) {
            return _Val._Get_first();
        } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
            auto&& _Tmp = *_Val._Get_first();
            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._Get_first()};
        }
    }

    constexpr common_iterator& operator++() {

        do { if (_Val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 960, 0, "%s", "common_iterator can only be incremented if it holds an iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"common_iterator can only be incremented if it holds an iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 960, 0); } while (false); } ; } while (false);
#line 961 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 962 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        ++_Val._Get_first();
        return *this;
    }

    constexpr decltype(auto) operator++(int) {

        do { if (_Val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 969, 0, "%s", "common_iterator can only be incremented if it holds an iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"common_iterator can only be incremented if it holds an iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 969, 0); } while (false); } ; } while (false);
#line 970 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 971 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        if constexpr (forward_iterator<_Iter>) {
            common_iterator _Tmp = *this;
            ++_Val._Get_first();
            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._Get_first()};
            ++_Val._Get_first();
            return _Tmp;
        } else {
            return _Val._Get_first()++;
        }
    }

    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();

        do { if (_Left._Val._Contains != _Variantish_state::_Nothing && _Right_val._Contains != _Variantish_state::_Nothing) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1003, 0, "%s", "common_iterators can only be compared if both hold a value")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"common_iterators can only be compared if both hold a value\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1003, 0); } while (false); } ; } while (false);
#line 1004 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 1005 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

        if (_Left._Val._Contains == _Variantish_state::_Holds_first) {
            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
                if constexpr (equality_comparable_with<_Iter, _OIter>) {
                    return _Left._Val._Get_first() == _Right_val._Get_first();
                } else {
                    return true;
                }
            } else {
                return _Left._Val._Get_first() == _Right_val._Get_second();
            }
        } else {
            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
                return _Left._Val._Get_second() == _Right_val._Get_first();
            } 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();

        do { if (_Left._Val._Contains != _Variantish_state::_Nothing && _Right_val._Contains != _Variantish_state::_Nothing) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1033, 0, "%s", "Cannot take difference of valueless common_iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot take difference of valueless common_iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1033, 0); } while (false); } ; } while (false);
#line 1034 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 1035 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

        if (_Left._Val._Contains == _Variantish_state::_Holds_first) {
            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
                return _Left._Val._Get_first() - _Right_val._Get_first();
            } else {
                return _Left._Val._Get_first() - _Right_val._Get_second();
            }
        } else {
            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
                return _Left._Val._Get_second() - _Right_val._Get_first();
            } 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._Get_first())))
        requires input_iterator<_Iter>
    {

        do { if (_Right._Val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1057, 0, "%s", "can only iter_move from common_iterator if it holds an iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can only iter_move from common_iterator if it holds an iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1057, 0); } while (false); } ; } while (false);
#line 1058 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 1059 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return ::std::ranges:: iter_move(_Right._Val._Get_first());
    }

    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._Get_first(), _Right._Get_val()._Get_first()))) {
        auto& _Right_val = _Right._Get_val();

        do { if (_Left._Val._Contains == _Variantish_state::_Holds_first && _Right_val._Contains == _Variantish_state::_Holds_first) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1069, 0, "%s", "can only iter_swap common_iterators if both hold iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can only iter_swap common_iterators if both hold iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1069, 0); } while (false); } ; } while (false);
#line 1070 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 1071 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return ::std::ranges:: iter_swap(_Left._Val._Get_first(), _Right_val._Get_first());
    }

    [[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) {

        do { if (_Diff >= 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1156, 0, "%s", "counted_iterator requires non-negative length n")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator requires non-negative length n\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1156, 0); } while (false); } ; } while (false);
#line 1158 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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))  {

        do { if (_Length > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1191, 0, "%s", "counted_iterator dereference beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator dereference beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1191, 0); } while (false); } ; } while (false);
#line 1193 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return *_Current;
    }

    [[nodiscard]] constexpr decltype(auto) operator*() const noexcept(noexcept(*_Current)) 
        requires _Dereferenceable<const _Iter>
    {

        do { if (_Length > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1200, 0, "%s", "counted_iterator dereference beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator dereference beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1200, 0); } while (false); } ; } while (false);
#line 1202 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    {

        do { if (_Diff < _Length) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1215, 0, "%s", "counted_iterator index out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator index out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1215, 0); } while (false); } ; } while (false);
#line 1217 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return _Current[_Diff];
    }

    
    constexpr counted_iterator& operator++() {

        do { if (_Length > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1223, 0, "%s", "counted_iterator increment beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator increment beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1223, 0); } while (false); } ; } while (false);
#line 1225 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        ++_Current;
        --_Length;
        return *this;
    }

    constexpr decltype(auto) operator++(int) {

        do { if (_Length > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1232, 0, "%s", "counted_iterator increment beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator increment beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1232, 0); } while (false); } ; } while (false);
#line 1234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        --_Length;
        try {
        return _Current++;

        } catch (...) {
        ++_Length;

        throw;
        }
    }

    constexpr counted_iterator operator++(int)
        requires forward_iterator<_Iter>
    {

        do { if (_Length > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1249, 0, "%s", "counted_iterator increment beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator increment beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1249, 0); } while (false); } ; } while (false);
#line 1251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    {

        do { if (_Diff <= _Length) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1291, 0, "%s", "counted_iterator seek beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator seek beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1291, 0); } while (false); } ; } while (false);
#line 1293 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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  {

        _Same_sequence(_Left, _Right);
#line 1310 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    {

        do { if (-_Diff <= _Length) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1327, 0, "%s", "counted_iterator decrement beyond end of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterator decrement beyond end of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1327, 0); } while (false); } ; } while (false);
#line 1329 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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  {

        _Same_sequence(_Left, _Right);
#line 1341 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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  {

        _Same_sequence(_Left, _Right);
#line 1355 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1393, 0, "%s", "counted_iterators are from different ranges")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterators are from different ranges\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1393, 0); } while (false); } ; } while (false);
#line 1394 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
            } else {
                do { if (::std::ranges:: next(static_cast<_CIter>(_Left._Current), _Diff) == static_cast<_CIter>(_Right.base())) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1397, 0, "%s", "counted_iterators are from different ranges")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"counted_iterators are from different ranges\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1397, 0); } while (false); } ; } while (false);
#line 1398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
            }
        }
#line 1401 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
    }
#line 1403 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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());
        }

        _Same_sequence(_Left, _Right);
#line 1412 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
    }

    constexpr void _Verify_offset(const iter_difference_t<_Iter> _Off) const {

        do { if (_Off <= _Length) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1416, 0, "%s", "Offset larger than counted_iterator length")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Offset larger than counted_iterator length\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1416, 0); } while (false); } ; } while (false);
#line 1418 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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& noexcept(
        noexcept(counted_iterator<_Unwrapped_t<const _Iter&>>{_Current._Unwrapped(), _Length}))
        requires _Unwrappable_v<const _Iter&>
    {
        return counted_iterator<_Unwrapped_t<const _Iter&>>{_Current._Unwrapped(), _Length};
    }

    [[nodiscard]] constexpr counted_iterator<_Unwrapped_t<_Iter>> _Unwrapped() && noexcept(
        noexcept(counted_iterator<_Unwrapped_t<_Iter>>{::std:: move(_Current)._Unwrapped(), _Length}))
        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 1466 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

}

namespace stdext {
using ::std:: size_t;

template <class _Ptr>
class [[deprecated( "warning STL4043: stdext::checked_array_iterator, stdext::unchecked_array_iterator, and related factory " "functions are non-Standard extensions and will be removed in the future. std::span (since C++20) " "and gsl::span can be used instead. You can define _SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] checked_array_iterator { 
private:
    using _Pointee_type = ::std:: remove_pointer_t<_Ptr>;
    static_assert(::std:: is_pointer_v<_Ptr> && ::std:: is_object_v<_Pointee_type>,
        "checked_array_iterator requires pointers to objects");

public:
    using iterator_category = ::std:: random_access_iterator_tag;
    using value_type        = ::std:: remove_cv_t<_Pointee_type>;
    using difference_type   = ::std:: ptrdiff_t;
    using pointer           = _Ptr;
    using reference         = _Pointee_type&;

    using iterator_concept = ::std:: contiguous_iterator_tag;
#line 1488 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

    constexpr checked_array_iterator() = default;

    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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1493, 0, "%s", "checked_array_iterator construction index out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"checked_array_iterator construction index out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1493, 0); } while (false); } ; } while (false);
    }

    __pragma(warning(push)) __pragma(warning(disable : 4996))
    template <class _Ty = _Pointee_type, ::std:: enable_if_t<!::std:: is_const_v<_Ty>, int> = 0>
    constexpr operator checked_array_iterator<const _Ty*>() const noexcept {
        return checked_array_iterator<const _Ty*>{_Myarray, _Mysize, _Myindex};
    }
    __pragma(warning(pop))

    [[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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1512, 0, "%s", "cannot dereference value-initialized or null checked_array_iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized or null checked_array_iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1512, 0); } while (false); } ; } while (false);
        do { if (_Myindex < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1513, 0, "%s", "cannot dereference end checked_array_iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end checked_array_iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1513, 0); } while (false); } ; } while (false);
        return _Myarray + _Myindex;
    }

    constexpr checked_array_iterator& operator++() noexcept {
        do { if (_Myarray) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1518, 0, "%s", "cannot increment value-initialized or null checked_array_iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized or null checked_array_iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1518, 0); } while (false); } ; } while (false);
        do { if (_Myindex < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1519, 0, "%s", "cannot increment checked_array_iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment checked_array_iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1519, 0); } 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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1531, 0, "%s", "cannot decrement value-initialized or null checked_array_iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized or null checked_array_iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1531, 0); } while (false); } ; } while (false);
        do { if (_Myindex != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1532, 0, "%s", "cannot decrement checked_array_iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement checked_array_iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1532, 0); } 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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1545, 0, "%s", "cannot seek value-initialized or null checked_array_iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized or null checked_array_iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1545, 0); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Myindex >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1550, 0, "%s", "cannot seek checked_array_iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek checked_array_iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1550, 0); } while (false); } ; } while (false);
#line 1551 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        }

        if (_Off > 0) {
            do { if (_Mysize - _Myindex >= static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1555, 0, "%s", "cannot seek checked_array_iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek checked_array_iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1555, 0); } while (false); } ; } while (false);
#line 1556 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1575, 0, "%s", "cannot seek value-initialized or null checked_array_iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized or null checked_array_iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1575, 0); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            do { if (_Myindex >= static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1579, 0, "%s", "cannot seek checked_array_iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek checked_array_iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1579, 0); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Mysize - _Myindex >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1584, 0, "%s", "cannot seek checked_array_iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek checked_array_iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1584, 0); } while (false); } ; } while (false);
#line 1585 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1599, 0, "%s", "cannot subtract incompatible checked_array_iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot subtract incompatible checked_array_iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1599, 0); } while (false); } ; } while (false);
#line 1600 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1609, 0, "%s", "cannot compare incompatible checked_array_iterators for equality")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot compare incompatible checked_array_iterators for equality\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1609, 0); } while (false); } ; } while (false);
#line 1610 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1616, 0, "%s", "cannot compare incompatible checked_array_iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot compare incompatible checked_array_iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1616, 0); } while (false); } ; } while (false);
#line 1617 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        return _Myindex <=> _Right._Myindex;
    }






















#line 1642 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1646, 0, "%s", "mismatching checked_array_iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"mismatching checked_array_iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1646, 0); } while (false); } ; } while (false);
#line 1647 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        do { if (_First._Myindex <= _Last._Myindex) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1647, 0, "%s", "transposed checked_array_iterator range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"transposed checked_array_iterator range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1647, 0); } 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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1653, 0, "%s", "cannot seek checked_array_iterator iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek checked_array_iterator iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1653, 0); } while (false); } ; } while (false);
#line 1654 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
        }

        if (_Off > 0) {
            do { if (_Mysize - _Myindex >= static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1658, 0, "%s", "cannot seek checked_array_iterator iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek checked_array_iterator iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator", 1658, 0); } while (false); } ; } while (false);
#line 1659 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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   = nullptr; 
    size_t _Mysize  = 0; 
    size_t _Myindex = 0; 
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ptr>
[[deprecated( "warning STL4043: stdext::checked_array_iterator, stdext::unchecked_array_iterator, and related factory " "functions are non-Standard extensions and will be removed in the future. std::span (since C++20) " "and gsl::span can be used instead. You can define _SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] [[nodiscard]] constexpr checked_array_iterator<_Ptr> make_checked_array_iterator(
    const _Ptr _Array, const size_t _Size, const size_t _Index = 0) noexcept {
    return checked_array_iterator<_Ptr>(_Array, _Size, _Index);
}
__pragma(warning(pop))

template <class _Ptr>
class [[deprecated( "warning STL4043: stdext::checked_array_iterator, stdext::unchecked_array_iterator, and related factory " "functions are non-Standard extensions and will be removed in the future. std::span (since C++20) " "and gsl::span can be used instead. You can define _SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] unchecked_array_iterator { 
private:
    using _Pointee_type = ::std:: remove_pointer_t<_Ptr>;
    static_assert(::std:: is_pointer_v<_Ptr> && ::std:: is_object_v<_Pointee_type>,
        "unchecked_array_iterator requires pointers to objects");

public:
    using iterator_category = ::std:: random_access_iterator_tag;
    using value_type        = ::std:: remove_cv_t<_Pointee_type>;
    using difference_type   = ::std:: ptrdiff_t;
    using pointer           = _Ptr;
    using reference         = _Pointee_type&;

    using iterator_concept = ::std:: contiguous_iterator_tag;
#line 1702 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"

    constexpr unchecked_array_iterator() = default;

    constexpr explicit unchecked_array_iterator(const _Ptr _Src) noexcept : _Myptr(_Src) {}

    __pragma(warning(push)) __pragma(warning(disable : 4996))
    template <class _Ty = _Pointee_type, ::std:: enable_if_t<!::std:: is_const_v<_Ty>, int> = 0>
    constexpr operator unchecked_array_iterator<const _Ty*>() const noexcept {
        return unchecked_array_iterator<const _Ty*>{_Myptr};
    }
    __pragma(warning(pop))

    [[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 1811 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"


    friend constexpr void _Verify_range(
        const unchecked_array_iterator _First, const unchecked_array_iterator _Last) noexcept {
        ::std:: _Verify_range(_First._Myptr, _Last._Myptr);
    }
#line 1818 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = nullptr; 
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ptr>
[[deprecated( "warning STL4043: stdext::checked_array_iterator, stdext::unchecked_array_iterator, and related factory " "functions are non-Standard extensions and will be removed in the future. std::span (since C++20) " "and gsl::span can be used instead. You can define _SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] [[nodiscard]] unchecked_array_iterator<_Ptr> make_unchecked_array_iterator(
    const _Ptr _It) noexcept {
    return unchecked_array_iterator<_Ptr>(_It);
}
__pragma(warning(pop))
}


namespace std {
__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct pointer_traits<::stdext:: checked_array_iterator<_Ty*>> {
    using pointer         = ::stdext:: checked_array_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();
    }
};
__pragma(warning(pop))
}
#line 1860 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"



#pragma warning(pop)
#pragma pack(pop)
#line 1866 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#line 1867 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iterator"
#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"








#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"








__declspec(dllimport) char *qstrdup(const char *);

inline uint qstrlen(const char *str)
{ return str ? uint(strlen(str)) : 0; }

inline uint qstrnlen(const char *str, uint maxlen)
{
    uint length = 0;
    if (str) {
        while (length < maxlen && *str++)
            length++;
    }
    return length;
}

__declspec(dllimport) char *qstrcpy(char *dst, const char *src);
__declspec(dllimport) char *qstrncpy(char *dst, const char *src, uint len);

__declspec(dllimport) int qstrcmp(const char *str1, const char *str2);
__declspec(dllimport) int qstrcmp(const QByteArray &str1, const QByteArray &str2);
__declspec(dllimport) int qstrcmp(const QByteArray &str1, const char *str2);
static inline int qstrcmp(const char *str1, const QByteArray &str2)
{ return -qstrcmp(str2, str1); }

inline int qstrncmp(const char *str1, const char *str2, uint len)
{
    return (str1 && str2) ? strncmp(str1, str2, len)
        : (str1 ? 1 : (str2 ? -1 : 0));
}
__declspec(dllimport) int qstricmp(const char *, const char *);
__declspec(dllimport) int qstrnicmp(const char *, const char *, uint len);
__declspec(dllimport) int qstrnicmp(const char *, qsizetype, const char *, qsizetype = -1);


__declspec(dllimport) int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap);
__declspec(dllimport) int qsnprintf(char *str, size_t n, const char *fmt, ...);


__declspec(dllimport) quint16 qChecksum(const char *s, uint len);                            
__declspec(dllimport) quint16 qChecksum(const char *s, uint len, Qt::ChecksumType standard); 

class QByteRef;
class QString;
class QDataStream;
template <typename T> class QList;

typedef QArrayData QByteArrayData;

template<int N> struct QStaticByteArrayData
{
    QByteArrayData ba;
    char data[N + 1];

    QByteArrayData *data_ptr() const
    {
        ((ba.ref.isStatic()) ? static_cast<void>(0) : qt_assert("ba.ref.isStatic()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 126));
        return const_cast<QByteArrayData *>(&ba);
    }
};

struct QByteArrayDataPtr
{
    QByteArrayData *ptr;
};



    
















class __declspec(dllimport) QByteArray
{
private:
    typedef QTypedArrayData<char> Data;

public:
    enum Base64Option {
        Base64Encoding = 0,
        Base64UrlEncoding = 1,

        KeepTrailingEquals = 0,
        OmitTrailingEquals = 2,

        IgnoreBase64DecodingErrors = 0,
        AbortOnBase64DecodingErrors = 4,
    };
    typedef QFlags<Base64Option> Base64Options;

    enum class Base64DecodingStatus {
        Ok,
        IllegalInputLength,
        IllegalCharacter,
        IllegalPadding,
    };

    inline QByteArray() noexcept;
    QByteArray(const char *, int size = -1);
    QByteArray(int size, char c);
    QByteArray(int size, Qt::Initialization);
    inline QByteArray(const QByteArray &) noexcept;
    inline ~QByteArray();

    QByteArray &operator=(const QByteArray &) noexcept;
    QByteArray &operator=(const char *str);
    inline QByteArray(QByteArray && other) noexcept : d(other.d) { other.d = Data::sharedNull(); }
    inline QByteArray &operator=(QByteArray &&other) noexcept
    { qSwap(d, other.d); return *this; }

    inline void swap(QByteArray &other) noexcept
    { qSwap(d, other.d); }

    inline int size() const;
    inline bool isEmpty() const;
    void resize(int size);

    QByteArray &fill(char c, int size = -1);

    inline int capacity() const;
    inline void reserve(int size);
    inline void squeeze();





    inline char *data();
    inline const char *data() const;
    inline const char *constData() const;
    inline void detach();
    inline bool isDetached() const;
    inline bool isSharedWith(const QByteArray &other) const { return d == other.d; }
    void clear();

    inline char at(int i) const;
    inline char operator[](int i) const;
    inline char operator[](uint i) const;
    [[nodiscard]] inline QByteRef operator[](int i);
    [[nodiscard]] inline QByteRef operator[](uint i);
    [[nodiscard]] char front() const { return at(0); }
    [[nodiscard]] inline QByteRef front();
    [[nodiscard]] char back() const { return at(size() - 1); }
    [[nodiscard]] inline QByteRef back();

    int indexOf(char c, int from = 0) const;
    int indexOf(const char *c, int from = 0) const;
    int indexOf(const QByteArray &a, int from = 0) const;
    int lastIndexOf(char c, int from = -1) const;
    int lastIndexOf(const char *c, int from = -1) const;
    int lastIndexOf(const QByteArray &a, int from = -1) const;

    inline bool contains(char c) const;
    inline bool contains(const char *a) const;
    inline bool contains(const QByteArray &a) const;
    int count(char c) const;
    int count(const char *a) const;
    int count(const QByteArray &a) const;

    inline int compare(const char *c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    inline int compare(const QByteArray &a, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    [[nodiscard]] QByteArray left(int len) const;
    [[nodiscard]] QByteArray right(int len) const;
    [[nodiscard]] QByteArray mid(int index, int len = -1) const;
    [[nodiscard]] QByteArray chopped(int len) const
    { ((len >= 0) ? static_cast<void>(0) : qt_assert("len >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 249)); ((len <= size()) ? static_cast<void>(0) : qt_assert("len <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 249)); return left(size() - len); }

    bool startsWith(const QByteArray &a) const;
    bool startsWith(char c) const;
    bool startsWith(const char *c) const;

    bool endsWith(const QByteArray &a) const;
    bool endsWith(char c) const;
    bool endsWith(const char *c) const;

    bool isUpper() const;
    bool isLower() const;

    void truncate(int pos);
    void chop(int n);








#line 273 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
    [[nodiscard]] QByteArray toLower() const &
    { return toLower_helper(*this); }
    [[nodiscard]] QByteArray toLower() &&
    { return toLower_helper(*this); }
    [[nodiscard]] QByteArray toUpper() const &
    { return toUpper_helper(*this); }
    [[nodiscard]] QByteArray toUpper() &&
    { return toUpper_helper(*this); }
    [[nodiscard]] QByteArray trimmed() const &
    { return trimmed_helper(*this); }
    [[nodiscard]] QByteArray trimmed() &&
    { return trimmed_helper(*this); }
    [[nodiscard]] QByteArray simplified() const &
    { return simplified_helper(*this); }
    [[nodiscard]] QByteArray simplified() &&
    { return simplified_helper(*this); }








#line 298 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"

    [[nodiscard]] QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const;
    [[nodiscard]] QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const;

    QByteArray &prepend(char c);
    inline QByteArray &prepend(int count, char c);
    QByteArray &prepend(const char *s);
    QByteArray &prepend(const char *s, int len);
    QByteArray &prepend(const QByteArray &a);
    QByteArray &append(char c);
    inline QByteArray &append(int count, char c);
    QByteArray &append(const char *s);
    QByteArray &append(const char *s, int len);
    QByteArray &append(const QByteArray &a);
    QByteArray &insert(int i, char c);
    QByteArray &insert(int i, int count, char c);
    QByteArray &insert(int i, const char *s);
    QByteArray &insert(int i, const char *s, int len);
    QByteArray &insert(int i, const QByteArray &a);
    QByteArray &remove(int index, int len);
    QByteArray &replace(int index, int len, const char *s);
    QByteArray &replace(int index, int len, const char *s, int alen);
    QByteArray &replace(int index, int len, const QByteArray &s);
    inline QByteArray &replace(char before, const char *after);
    QByteArray &replace(char before, const QByteArray &after);
    inline QByteArray &replace(const char *before, const char *after);
    QByteArray &replace(const char *before, int bsize, const char *after, int asize);
    QByteArray &replace(const QByteArray &before, const QByteArray &after);
    inline QByteArray &replace(const QByteArray &before, const char *after);
    QByteArray &replace(const char *before, const QByteArray &after);
    QByteArray &replace(char before, char after);
    inline QByteArray &operator+=(char c);
    inline QByteArray &operator+=(const char *s);
    inline QByteArray &operator+=(const QByteArray &a);

    QList<QByteArray> split(char sep) const;

    [[nodiscard]] QByteArray repeated(int times) const;



















#line 356 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"

    inline bool operator==(const QString &s2) const;
    inline bool operator!=(const QString &s2) const;
    inline bool operator<(const QString &s2) const;
    inline bool operator>(const QString &s2) const;
    inline bool operator<=(const QString &s2) const;
    inline bool operator>=(const QString &s2) const;
#line 364 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"

    short toShort(bool *ok = nullptr, int base = 10) const;
    ushort toUShort(bool *ok = nullptr, int base = 10) const;
    int toInt(bool *ok = nullptr, int base = 10) const;
    uint toUInt(bool *ok = nullptr, int base = 10) const;
    long toLong(bool *ok = nullptr, int base = 10) const;
    ulong toULong(bool *ok = nullptr, int base = 10) const;
    qlonglong toLongLong(bool *ok = nullptr, int base = 10) const;
    qulonglong toULongLong(bool *ok = nullptr, int base = 10) const;
    float toFloat(bool *ok = nullptr) const;
    double toDouble(bool *ok = nullptr) const;
    QByteArray toBase64(Base64Options options) const;
    QByteArray toBase64() const; 
    QByteArray toHex() const;
    QByteArray toHex(char separator) const; 
    QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(),
                                 const QByteArray &include = QByteArray(),
                                 char percent = '%') const;

    inline QByteArray &setNum(short, int base = 10);
    inline QByteArray &setNum(ushort, int base = 10);
    inline QByteArray &setNum(int, int base = 10);
    inline QByteArray &setNum(uint, int base = 10);
    QByteArray &setNum(qlonglong, int base = 10);
    QByteArray &setNum(qulonglong, int base = 10);
    inline QByteArray &setNum(float, char f = 'g', int prec = 6);
    QByteArray &setNum(double, char f = 'g', int prec = 6);
    QByteArray &setRawData(const char *a, uint n); 

    [[nodiscard]] static QByteArray number(int, int base = 10);
    [[nodiscard]] static QByteArray number(uint, int base = 10);
    [[nodiscard]] static QByteArray number(qlonglong, int base = 10);
    [[nodiscard]] static QByteArray number(qulonglong, int base = 10);
    [[nodiscard]] static QByteArray number(double, char f = 'g', int prec = 6);
    [[nodiscard]] static QByteArray fromRawData(const char *, int size);

    class FromBase64Result;
    [[nodiscard]] static FromBase64Result fromBase64Encoding(QByteArray &&base64, Base64Options options = Base64Encoding);
    [[nodiscard]] static FromBase64Result fromBase64Encoding(const QByteArray &base64, Base64Options options = Base64Encoding);
    [[nodiscard]] static QByteArray fromBase64(const QByteArray &base64, Base64Options options);
    [[nodiscard]] static QByteArray fromBase64(const QByteArray &base64); 
    [[nodiscard]] static QByteArray fromHex(const QByteArray &hexEncoded);
    [[nodiscard]] static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%');










#line 418 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"

    typedef char *iterator;
    typedef const char *const_iterator;
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    inline iterator begin();
    inline const_iterator begin() const;
    inline const_iterator cbegin() const;
    inline const_iterator constBegin() const;
    inline iterator end();
    inline const_iterator end() const;
    inline const_iterator cend() const;
    inline const_iterator constEnd() const;
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }

    
    typedef int size_type;
    typedef qptrdiff difference_type;
    typedef const char & const_reference;
    typedef char & reference;
    typedef char *pointer;
    typedef const char *const_pointer;
    typedef char value_type;
    inline void push_back(char c);
    inline void push_back(const char *c);
    inline void push_back(const QByteArray &a);
    inline void push_front(char c);
    inline void push_front(const char *c);
    inline void push_front(const QByteArray &a);
    void shrink_to_fit() { squeeze(); }

    static inline QByteArray fromStdString(const std::string &s);
    inline std::string toStdString() const;

    inline int count() const { return d->size; }
    int length() const { return d->size; }
    bool isNull() const;

    inline QByteArray(QByteArrayDataPtr dd)
        : d(static_cast<Data *>(dd.ptr))
    {
    }

private:
    operator QNoImplicitBoolCast() const;
    Data *d;
    void reallocData(uint alloc, Data::AllocationOptions options);
    void expand(int i);
    QByteArray nulTerminated() const;

    static QByteArray toLower_helper(const QByteArray &a);
    static QByteArray toLower_helper(QByteArray &a);
    static QByteArray toUpper_helper(const QByteArray &a);
    static QByteArray toUpper_helper(QByteArray &a);
    static QByteArray trimmed_helper(const QByteArray &a);
    static QByteArray trimmed_helper(QByteArray &a);
    static QByteArray simplified_helper(const QByteArray &a);
    static QByteArray simplified_helper(QByteArray &a);

    friend class QByteRef;
    friend class QString;
    friend __declspec(dllimport) QByteArray qUncompress(const uchar *data, int nbytes);
public:
    typedef Data * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};

constexpr inline QFlags<QByteArray::Base64Options::enum_type> operator|(QByteArray::Base64Options::enum_type f1, QByteArray::Base64Options::enum_type f2) noexcept { return QFlags<QByteArray::Base64Options::enum_type>(f1) | f2; } constexpr inline QFlags<QByteArray::Base64Options::enum_type> operator|(QByteArray::Base64Options::enum_type f1, QFlags<QByteArray::Base64Options::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QByteArray::Base64Options::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

inline QByteArray::QByteArray() noexcept : d(Data::sharedNull()) { }
inline QByteArray::~QByteArray() { if (!d->ref.deref()) Data::deallocate(d); }
inline int QByteArray::size() const
{ return d->size; }

inline char QByteArray::at(int i) const
{ ((uint(i) < uint(size())) ? static_cast<void>(0) : qt_assert("uint(i) < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 500)); return d->data()[i]; }
inline char QByteArray::operator[](int i) const
{ ((uint(i) < uint(size())) ? static_cast<void>(0) : qt_assert("uint(i) < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 502)); return d->data()[i]; }
inline char QByteArray::operator[](uint i) const
{ ((i < uint(size())) ? static_cast<void>(0) : qt_assert("i < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 504)); return d->data()[i]; }

inline bool QByteArray::isEmpty() const
{ return d->size == 0; }






inline char *QByteArray::data()
{ detach(); return d->data(); }
inline const char *QByteArray::data() const
{ return d->data(); }
inline const char *QByteArray::constData() const
{ return d->data(); }
inline void QByteArray::detach()
{ if (d->ref.isShared() || (d->offset != sizeof(QByteArrayData))) reallocData(uint(d->size) + 1u, d->detachFlags()); }
inline bool QByteArray::isDetached() const
{ return !d->ref.isShared(); }
inline QByteArray::QByteArray(const QByteArray &a) noexcept : d(a.d)
{ d->ref.ref(); }

inline int QByteArray::capacity() const
{ return d->alloc ? d->alloc - 1 : 0; }

inline void QByteArray::reserve(int asize)
{
    if (d->ref.isShared() || uint(asize) + 1u > d->alloc) {
        reallocData(qMax(uint(size()), uint(asize)) + 1u, d->detachFlags() | Data::CapacityReserved);
    } else {
        
        
        d->capacityReserved = true;
    }
}

inline void QByteArray::squeeze()
{
    if (d->ref.isShared() || uint(d->size) + 1u < d->alloc) {
        reallocData(uint(d->size) + 1u, d->detachFlags() & ~Data::CapacityReserved);
    } else {
        
        
        d->capacityReserved = false;
    }
}

namespace QtPrivate {
namespace DeprecatedRefClassBehavior {
    enum class EmittingClass {
        QByteRef,
        QCharRef,
    };

    enum class WarningType {
        OutOfRange,
        DelayedDetach,
    };

    __declspec(dllimport)  void warn(WarningType w, EmittingClass c);
} 
} 

class

__declspec(dllimport)
#line 572 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
QByteRef {  
    QByteArray &a;
    int i;
    inline QByteRef(QByteArray &array, int idx)
        : a(array),i(idx) {}
    friend class QByteArray;
public:
    QByteRef(const QByteRef &) = default;
    inline operator char() const
    {
        using namespace QtPrivate::DeprecatedRefClassBehavior;
        if ((i < a.d->size))
            return a.d->data()[i];

        warn(WarningType::OutOfRange, EmittingClass::QByteRef);
#line 588 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
        return char(0);
    }
    inline QByteRef &operator=(char c)
    {
        using namespace QtPrivate::DeprecatedRefClassBehavior;
        if ((i >= a.d->size)) {

            warn(WarningType::OutOfRange, EmittingClass::QByteRef);
#line 597 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
            a.expand(i);
        } else {

            if ((!a.isDetached()))
                warn(WarningType::DelayedDetach, EmittingClass::QByteRef);
#line 603 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
            a.detach();
        }
        a.d->data()[i] = c;
        return *this;
    }
    inline QByteRef &operator=(const QByteRef &c)
    {
        return operator=(char(c));
    }
    inline bool operator==(char c) const
    { return a.d->data()[i] == c; }
    inline bool operator!=(char c) const
    { return a.d->data()[i] != c; }
    inline bool operator>(char c) const
    { return a.d->data()[i] > c; }
    inline bool operator>=(char c) const
    { return a.d->data()[i] >= c; }
    inline bool operator<(char c) const
    { return a.d->data()[i] < c; }
    inline bool operator<=(char c) const
    { return a.d->data()[i] <= c; }
};

inline QByteRef QByteArray::operator[](int i)
{ ((i >= 0) ? static_cast<void>(0) : qt_assert("i >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h", 627)); detach(); return QByteRef(*this, i); }
inline QByteRef QByteArray::operator[](uint i)
{  detach(); return QByteRef(*this, i); }
inline QByteRef QByteArray::front() { return operator[](0); }
inline QByteRef QByteArray::back() { return operator[](size() - 1); }
inline QByteArray::iterator QByteArray::begin()
{ detach(); return d->data(); }
inline QByteArray::const_iterator QByteArray::begin() const
{ return d->data(); }
inline QByteArray::const_iterator QByteArray::cbegin() const
{ return d->data(); }
inline QByteArray::const_iterator QByteArray::constBegin() const
{ return d->data(); }
inline QByteArray::iterator QByteArray::end()
{ detach(); return d->data() + d->size; }
inline QByteArray::const_iterator QByteArray::end() const
{ return d->data() + d->size; }
inline QByteArray::const_iterator QByteArray::cend() const
{ return d->data() + d->size; }
inline QByteArray::const_iterator QByteArray::constEnd() const
{ return d->data() + d->size; }
inline QByteArray &QByteArray::append(int n, char ch)
{ return insert(d->size, n, ch); }
inline QByteArray &QByteArray::prepend(int n, char ch)
{ return insert(0, n, ch); }
inline QByteArray &QByteArray::operator+=(char c)
{ return append(c); }
inline QByteArray &QByteArray::operator+=(const char *s)
{ return append(s); }
inline QByteArray &QByteArray::operator+=(const QByteArray &a)
{ return append(a); }
inline void QByteArray::push_back(char c)
{ append(c); }
inline void QByteArray::push_back(const char *c)
{ append(c); }
inline void QByteArray::push_back(const QByteArray &a)
{ append(a); }
inline void QByteArray::push_front(char c)
{ prepend(c); }
inline void QByteArray::push_front(const char *c)
{ prepend(c); }
inline void QByteArray::push_front(const QByteArray &a)
{ prepend(a); }
inline bool QByteArray::contains(const QByteArray &a) const
{ return indexOf(a) != -1; }
inline bool QByteArray::contains(char c) const
{ return indexOf(c) != -1; }
inline int QByteArray::compare(const char *c, Qt::CaseSensitivity cs) const noexcept
{
    return cs == Qt::CaseSensitive ? qstrcmp(*this, c) :
                                     qstrnicmp(data(), size(), c, -1);
}
inline int QByteArray::compare(const QByteArray &a, Qt::CaseSensitivity cs) const noexcept
{
    return cs == Qt::CaseSensitive ? qstrcmp(*this, a) :
                                     qstrnicmp(data(), size(), a.data(), a.size());
}
inline bool operator==(const QByteArray &a1, const QByteArray &a2) noexcept
{ return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); }
inline bool operator==(const QByteArray &a1, const char *a2) noexcept
{ return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); }
inline bool operator==(const char *a1, const QByteArray &a2) noexcept
{ return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); }
inline bool operator!=(const QByteArray &a1, const QByteArray &a2) noexcept
{ return !(a1==a2); }
inline bool operator!=(const QByteArray &a1, const char *a2) noexcept
{ return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); }
inline bool operator!=(const char *a1, const QByteArray &a2) noexcept
{ return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); }
inline bool operator<(const QByteArray &a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) < 0; }
 inline bool operator<(const QByteArray &a1, const char *a2) noexcept
{ return qstrcmp(a1, a2) < 0; }
inline bool operator<(const char *a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) < 0; }
inline bool operator<=(const QByteArray &a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) <= 0; }
inline bool operator<=(const QByteArray &a1, const char *a2) noexcept
{ return qstrcmp(a1, a2) <= 0; }
inline bool operator<=(const char *a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) <= 0; }
inline bool operator>(const QByteArray &a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) > 0; }
inline bool operator>(const QByteArray &a1, const char *a2) noexcept
{ return qstrcmp(a1, a2) > 0; }
inline bool operator>(const char *a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) > 0; }
inline bool operator>=(const QByteArray &a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) >= 0; }
inline bool operator>=(const QByteArray &a1, const char *a2) noexcept
{ return qstrcmp(a1, a2) >= 0; }
inline bool operator>=(const char *a1, const QByteArray &a2) noexcept
{ return qstrcmp(a1, a2) >= 0; }











#line 732 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
inline bool QByteArray::contains(const char *c) const
{ return indexOf(c) != -1; }
inline QByteArray &QByteArray::replace(char before, const char *c)
{ return replace(&before, 1, c, qstrlen(c)); }
inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c)
{ return replace(before.constData(), before.size(), c, qstrlen(c)); }
inline QByteArray &QByteArray::replace(const char *before, const char *after)
{ return replace(before, qstrlen(before), after, qstrlen(after)); }

inline QByteArray &QByteArray::setNum(short n, int base)
{ return base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(ushort(n)), base); }
inline QByteArray &QByteArray::setNum(ushort n, int base)
{ return setNum(qulonglong(n), base); }
inline QByteArray &QByteArray::setNum(int n, int base)
{ return base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(uint(n)), base); }
inline QByteArray &QByteArray::setNum(uint n, int base)
{ return setNum(qulonglong(n), base); }
inline QByteArray &QByteArray::setNum(float n, char f, int prec)
{ return setNum(double(n),f,prec); }

inline std::string QByteArray::toStdString() const
{ return std::string(constData(), length()); }

inline QByteArray QByteArray::fromStdString(const std::string &s)
{ return QByteArray(s.data(), int(s.size())); }


__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QByteArray &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QByteArray &);
#line 762 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"


__declspec(dllimport) QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1);
__declspec(dllimport) QByteArray qUncompress(const uchar* data, int nbytes);
inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1)
{ return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); }
inline QByteArray qUncompress(const QByteArray& data)
{ return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); }
#line 771 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"

template<> class QTypeInfo<QByteArray > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QByteArray>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QByteArray>(), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QByteArray >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QByteArray) }; static inline const char *name() { return "QByteArray"; } }; inline void swap(QByteArray &value1, QByteArray &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }

class QByteArray::FromBase64Result
{
public:
    QByteArray decoded;
    QByteArray::Base64DecodingStatus decodingStatus;

    void swap(QByteArray::FromBase64Result &other) noexcept
    {
        qSwap(decoded, other.decoded);
        qSwap(decodingStatus, other.decodingStatus);
    }

    explicit operator bool() const noexcept { return decodingStatus == QByteArray::Base64DecodingStatus::Ok; }


    QByteArray &operator*() & noexcept { return decoded; }
    const QByteArray &operator*() const & noexcept { return decoded; }
    QByteArray &&operator*() && noexcept { return std::move(decoded); }



#line 796 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
};

template<> class QTypeInfo<QByteArray::FromBase64Result > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QByteArray::FromBase64Result>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QByteArray::FromBase64Result>(), isLarge = (sizeof(QByteArray::FromBase64Result)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QByteArray::FromBase64Result >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QByteArray::FromBase64Result) }; static inline const char *name() { return "QByteArray::FromBase64Result"; } }; inline void swap(QByteArray::FromBase64Result &value1, QByteArray::FromBase64Result &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }

inline bool operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
{
    if (lhs.decodingStatus != rhs.decodingStatus)
        return false;

    if (lhs.decodingStatus == QByteArray::Base64DecodingStatus::Ok && lhs.decoded != rhs.decoded)
        return false;

    return true;
}

inline bool operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
{
    return !operator==(lhs, rhs);
}

__declspec(dllimport)  uint qHash(const QByteArray::FromBase64Result &key, uint seed = 0) noexcept;



#line 821 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearray.h"
#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringliteral.h"















































#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringliteral.h"



typedef QTypedArrayData<ushort> QStringData;






typedef char16_t qunicodechar;

static_assert(bool(sizeof(qunicodechar) == 2), "qunicodechar must typedef an integral type of size 2");
#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringliteral.h"























#line 87 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringliteral.h"

template <int N>
struct QStaticStringData
{
    QArrayData str;
    qunicodechar data[N + 1];

    QStringData *data_ptr() const
    {
        ((str.ref.isStatic()) ? static_cast<void>(0) : qt_assert("str.ref.isStatic()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringliteral.h", 96));
        return const_cast<QStringData *>(static_cast<const QStringData*>(&str));
    }
};

struct QStringDataPtr
{
    QStringData *ptr;
};



#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringliteral.h"
#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringalgorithms.h"














































#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringalgorithms.h"



class QByteArray;
class QLatin1String;
class QStringView;
class QChar;
template <typename T> class QVector;

namespace QtPrivate {

[[nodiscard]] __declspec(dllimport)  qsizetype qustrlen(const ushort *str) noexcept;
[[nodiscard]] __declspec(dllimport)  const ushort *qustrchr(QStringView str, ushort ch) noexcept;

[[nodiscard]] __declspec(dllimport)  int compareStrings(QStringView   lhs, QStringView   rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  int compareStrings(QStringView   lhs, QLatin1String rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  int compareStrings(QLatin1String lhs, QStringView   rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  int compareStrings(QLatin1String lhs, QLatin1String rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;


[[nodiscard]] __declspec(dllimport)  bool startsWith(QStringView   haystack, QStringView   needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  bool startsWith(QStringView   haystack, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  bool startsWith(QLatin1String haystack, QStringView   needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  bool startsWith(QLatin1String haystack, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;

[[nodiscard]] __declspec(dllimport)  bool endsWith(QStringView   haystack, QStringView   needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  bool endsWith(QStringView   haystack, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  bool endsWith(QLatin1String haystack, QStringView   needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  bool endsWith(QLatin1String haystack, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;

[[nodiscard]] __declspec(dllimport)  qsizetype findString(QStringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  qsizetype findString(QStringView haystack, qsizetype from, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  qsizetype findString(QLatin1String haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  qsizetype findString(QLatin1String haystack, qsizetype from, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;

[[nodiscard]] __declspec(dllimport)  qsizetype lastIndexOf(QStringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  qsizetype lastIndexOf(QStringView haystack, qsizetype from, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  qsizetype lastIndexOf(QLatin1String haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
[[nodiscard]] __declspec(dllimport)  qsizetype lastIndexOf(QLatin1String haystack, qsizetype from, QLatin1String needle, Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;

[[nodiscard]] __declspec(dllimport)  QStringView   trimmed(QStringView   s) noexcept;
[[nodiscard]] __declspec(dllimport)  QLatin1String trimmed(QLatin1String s) noexcept;

[[nodiscard]] __declspec(dllimport) QByteArray convertToLatin1(QStringView str);
[[nodiscard]] __declspec(dllimport) QByteArray convertToUtf8(QStringView str);
[[nodiscard]] __declspec(dllimport) QByteArray convertToLocal8Bit(QStringView str);
[[nodiscard]] __declspec(dllimport) QVector<uint> convertToUcs4(QStringView str);

[[nodiscard]] __declspec(dllimport)  bool isRightToLeft(QStringView string) noexcept;

[[nodiscard]] __declspec(dllimport)  bool isAscii(QLatin1String s) noexcept;
[[nodiscard]] __declspec(dllimport)  bool isAscii(QStringView   s) noexcept;
[[nodiscard]] constexpr inline            bool isLatin1(QLatin1String s) noexcept;
[[nodiscard]] __declspec(dllimport)  bool isLatin1(QStringView   s) noexcept;
[[nodiscard]] __declspec(dllimport)  bool isValidUtf16(QStringView s) noexcept;

} 



#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringalgorithms.h"
#pragma external_header(pop)
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"












































#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"










class QString;
class QStringRef;
class QRegularExpression;

namespace QtPrivate {
template <typename Char>
struct IsCompatibleCharTypeHelper
    : std::integral_constant<bool,
                             std::is_same<Char, QChar>::value ||
                             std::is_same<Char, ushort>::value ||
                             std::is_same<Char, char16_t>::value ||
                             (std::is_same<Char, wchar_t>::value && sizeof(wchar_t) == sizeof(QChar))> {};
template <typename Char>
struct IsCompatibleCharType
    : IsCompatibleCharTypeHelper<typename std::remove_cv<typename std::remove_reference<Char>::type>::type> {};

template <typename Array>
struct IsCompatibleArrayHelper : std::false_type {};
template <typename Char, size_t N>
struct IsCompatibleArrayHelper<Char[N]>
    : IsCompatibleCharType<Char> {};
template <typename Array>
struct IsCompatibleArray
    : IsCompatibleArrayHelper<typename std::remove_cv<typename std::remove_reference<Array>::type>::type> {};

template <typename Pointer>
struct IsCompatiblePointerHelper : std::false_type {};
template <typename Char>
struct IsCompatiblePointerHelper<Char*>
    : IsCompatibleCharType<Char> {};
template <typename Pointer>
struct IsCompatiblePointer
    : IsCompatiblePointerHelper<typename std::remove_cv<typename std::remove_reference<Pointer>::type>::type> {};

template <typename T>
struct IsCompatibleStdBasicStringHelper : std::false_type {};
template <typename Char, typename...Args>
struct IsCompatibleStdBasicStringHelper<std::basic_string<Char, Args...> >
    : IsCompatibleCharType<Char> {};

template <typename T>
struct IsCompatibleStdBasicString
    : IsCompatibleStdBasicStringHelper<
        typename std::remove_cv<typename std::remove_reference<T>::type>::type
      > {};

} 

class QStringView
{
public:
    typedef char16_t storage_type;
    typedef const QChar value_type;
    typedef std::ptrdiff_t difference_type;
    typedef qsizetype size_type;
    typedef value_type &reference;
    typedef value_type &const_reference;
    typedef value_type *pointer;
    typedef value_type *const_pointer;

    typedef pointer iterator;
    typedef const_pointer const_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

private:
    template <typename Char>
    using if_compatible_char = typename std::enable_if<QtPrivate::IsCompatibleCharType<Char>::value, bool>::type;

    template <typename Array>
    using if_compatible_array = typename std::enable_if<QtPrivate::IsCompatibleArray<Array>::value, bool>::type;

    template <typename Pointer>
    using if_compatible_pointer = typename std::enable_if<QtPrivate::IsCompatiblePointer<Pointer>::value, bool>::type;

    template <typename T>
    using if_compatible_string = typename std::enable_if<QtPrivate::IsCompatibleStdBasicString<T>::value, bool>::type;

    template <typename T>
    using if_compatible_qstring_like = typename std::enable_if<std::is_same<T, QString>::value || std::is_same<T, QStringRef>::value, bool>::type;

    template <typename Char, size_t N>
    static constexpr qsizetype lengthHelperArray(const Char (&)[N]) noexcept
    {
        return qsizetype(N - 1);
    }

    template <typename Char>
    static constexpr qsizetype lengthHelperPointer(const Char *str) noexcept
    {







#line 154 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"
        return QtPrivate::qustrlen(reinterpret_cast<const ushort *>(str));
    }
    static qsizetype lengthHelperPointer(const QChar *str) noexcept
    {
        return QtPrivate::qustrlen(reinterpret_cast<const ushort *>(str));
    }

    template <typename Char>
    static const storage_type *castHelper(const Char *str) noexcept
    { return reinterpret_cast<const storage_type*>(str); }
    static constexpr const storage_type *castHelper(const storage_type *str) noexcept
    { return str; }

public:
    constexpr QStringView() noexcept
        : m_size(0), m_data(nullptr) {}
    constexpr QStringView(std::nullptr_t) noexcept
        : QStringView() {}

    template <typename Char, if_compatible_char<Char> = true>
    constexpr QStringView(const Char *str, qsizetype len)
        : m_size((((len >= 0) ? static_cast<void>(0) : qt_assert("len >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 175)), ((str || !len) ? static_cast<void>(0) : qt_assert("str || !len", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 175)), len)),
          m_data(castHelper(str)) {}

    template <typename Char, if_compatible_char<Char> = true>
    constexpr QStringView(const Char *f, const Char *l)
        : QStringView(f, l - f) {}













#line 195 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"

    template <typename Array, if_compatible_array<Array> = true>
    constexpr QStringView(const Array &str) noexcept
        : QStringView(str, lengthHelperArray(str)) {}

    template <typename Pointer, if_compatible_pointer<Pointer> = true>
    constexpr QStringView(const Pointer &str) noexcept
        : QStringView(str, str ? lengthHelperPointer(str) : 0) {}
#line 204 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"





    template <typename String, if_compatible_qstring_like<String> = true>
    QStringView(const String &str) noexcept
        : QStringView(str.isNull() ? nullptr : str.data(), qsizetype(str.size())) {}
#line 213 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"

    template <typename StdBasicString, if_compatible_string<StdBasicString> = true>
    constexpr QStringView(const StdBasicString &str) noexcept
        : QStringView(str.data(), qsizetype(str.size())) {}

    [[nodiscard]] inline QString toString() const; 

    [[nodiscard]] constexpr qsizetype size() const noexcept { return m_size; }
    [[nodiscard]] const_pointer data() const noexcept { return reinterpret_cast<const_pointer>(m_data); }
    [[nodiscard]] constexpr const storage_type *utf16() const noexcept { return m_data; }

    [[nodiscard]] constexpr QChar operator[](qsizetype n) const
    { return ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 225)), ((n < size()) ? static_cast<void>(0) : qt_assert("n < size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 225)), QChar(m_data[n]); }

    
    
    

    template <typename...Args>
    [[nodiscard]] inline QString arg(Args &&...args) const; 

    [[nodiscard]] QByteArray toLatin1() const { return QtPrivate::convertToLatin1(*this); }
    [[nodiscard]] QByteArray toUtf8() const { return QtPrivate::convertToUtf8(*this); }
    [[nodiscard]] QByteArray toLocal8Bit() const { return QtPrivate::convertToLocal8Bit(*this); }
    [[nodiscard]] inline QVector<uint> toUcs4() const; 

    [[nodiscard]] constexpr QChar at(qsizetype n) const { return (*this)[n]; }

    [[nodiscard]] constexpr QStringView mid(qsizetype pos) const
    {
        return QStringView(m_data + qBound(qsizetype(0), pos, m_size), m_size - qBound(qsizetype(0), pos, m_size));
    }
    [[nodiscard]] constexpr QStringView mid(qsizetype pos, qsizetype n) const
    {
        return QStringView(m_data + qBound(qsizetype(0), pos, m_size),
            n == -1 ? m_size - pos : qBound(qsizetype(0), pos + n, m_size) - qBound(qsizetype(0), pos, m_size));
    }
    [[nodiscard]] constexpr QStringView left(qsizetype n) const
    {
        return QStringView(m_data, (size_t(n) > size_t(m_size) ? m_size : n));
    }
    [[nodiscard]] constexpr QStringView right(qsizetype n) const
    {
        return QStringView(m_data + m_size - (size_t(n) > size_t(m_size) ? m_size : n), (size_t(n) > size_t(m_size) ? m_size : n));
    }
    [[nodiscard]] constexpr QStringView chopped(qsizetype n) const
    { return ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 259)), ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 259)), QStringView(m_data, m_size - n); }

    constexpr void truncate(qsizetype n)
    { ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 262)); ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 262)); m_size = n; }
    constexpr void chop(qsizetype n)
    { ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 264)); ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 264)); m_size -= n; }

    [[nodiscard]] QStringView trimmed() const noexcept { return QtPrivate::trimmed(*this); }

    [[nodiscard]] int compare(QStringView other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::compareStrings(*this, other, cs); }
    [[nodiscard]] inline int compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    [[nodiscard]] constexpr int compare(QChar c) const noexcept
    { return size() >= 1 ? compare_single_char_helper(*utf16() - c.unicode()) : -1; }
    [[nodiscard]] int compare(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::compareStrings(*this, QStringView(&c, 1), cs); }

    [[nodiscard]] bool startsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }
    [[nodiscard]] inline bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    [[nodiscard]] bool startsWith(QChar c) const noexcept
    { return !empty() && front() == c; }
    [[nodiscard]] bool startsWith(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::startsWith(*this, QStringView(&c, 1), cs); }

    [[nodiscard]] bool endsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }
    [[nodiscard]] inline bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    [[nodiscard]] bool endsWith(QChar c) const noexcept
    { return !empty() && back() == c; }
    [[nodiscard]] bool endsWith(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::endsWith(*this, QStringView(&c, 1), cs); }

    [[nodiscard]] qsizetype indexOf(QChar c, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::findString(*this, from, QStringView(&c, 1), cs); }
    [[nodiscard]] qsizetype indexOf(QStringView s, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::findString(*this, from, s, cs); }
    [[nodiscard]] inline qsizetype indexOf(QLatin1String s, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    [[nodiscard]] bool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(QStringView(&c, 1), 0, cs) != qsizetype(-1); }
    [[nodiscard]] bool contains(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(s, 0, cs) != qsizetype(-1); }
    [[nodiscard]] inline bool contains(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    [[nodiscard]] inline qsizetype count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    [[nodiscard]] inline qsizetype count(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    [[nodiscard]] qsizetype lastIndexOf(QChar c, qsizetype from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::lastIndexOf(*this, from, QStringView(&c, 1), cs); }
    [[nodiscard]] qsizetype lastIndexOf(QStringView s, qsizetype from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::lastIndexOf(*this, from, s, cs); }
    [[nodiscard]] inline qsizetype lastIndexOf(QLatin1String s, qsizetype from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    [[nodiscard]] bool isRightToLeft() const noexcept
    { return QtPrivate::isRightToLeft(*this); }
    [[nodiscard]] bool isValidUtf16() const noexcept
    { return QtPrivate::isValidUtf16(*this); }

    [[nodiscard]] inline short toShort(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline ushort toUShort(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline int toInt(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline uint toUInt(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline long toLong(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline ulong toULong(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline qlonglong toLongLong(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline qulonglong toULongLong(bool *ok = nullptr, int base = 10) const;
    [[nodiscard]] inline float toFloat(bool *ok = nullptr) const;
    [[nodiscard]] inline double toDouble(bool *ok = nullptr) const;

    [[nodiscard]] inline int toWCharArray(wchar_t *array) const; 

    [[nodiscard]] inline
    QList<QStringView> split(QStringView sep,
                             Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                             Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    [[nodiscard]] inline
    QList<QStringView> split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                             Qt::CaseSensitivity cs = Qt::CaseSensitive) const;


    [[nodiscard]] inline
    QList<QStringView> split(const QRegularExpression &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const;
#line 343 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"

    
    
    
    [[nodiscard]] const_iterator begin()   const noexcept { return data(); }
    [[nodiscard]] const_iterator end()     const noexcept { return data() + size(); }
    [[nodiscard]] const_iterator cbegin()  const noexcept { return begin(); }
    [[nodiscard]] const_iterator cend()    const noexcept { return end(); }
    [[nodiscard]] const_reverse_iterator rbegin()  const noexcept { return const_reverse_iterator(end()); }
    [[nodiscard]] const_reverse_iterator rend()    const noexcept { return const_reverse_iterator(begin()); }
    [[nodiscard]] const_reverse_iterator crbegin() const noexcept { return rbegin(); }
    [[nodiscard]] const_reverse_iterator crend()   const noexcept { return rend(); }

    [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; }
    [[nodiscard]] constexpr QChar front() const { return ((!empty()) ? static_cast<void>(0) : qt_assert("!empty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 357)), QChar(m_data[0]); }
    [[nodiscard]] constexpr QChar back()  const { return ((!empty()) ? static_cast<void>(0) : qt_assert("!empty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 358)), QChar(m_data[m_size - 1]); }

    
    
    
    [[nodiscard]] constexpr bool isNull() const noexcept { return !m_data; }
    [[nodiscard]] constexpr bool isEmpty() const noexcept { return empty(); }
    [[nodiscard]] constexpr int length() const 
    { return ((int(size()) == size()) ? static_cast<void>(0) : qt_assert("int(size()) == size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h", 366)), int(size()); }
    [[nodiscard]] constexpr QChar first() const { return front(); }
    [[nodiscard]] constexpr QChar last()  const { return back(); }
private:
    qsizetype m_size;
    const storage_type *m_data;

    constexpr int compare_single_char_helper(int diff) const noexcept
    { return diff ? diff : size() > 1 ? 1 : 0; }
};
template<> class QTypeInfo<QStringView > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QStringView>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QStringView>(), isLarge = (sizeof(QStringView)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QStringView >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QStringView) }; static inline const char *name() { return "QStringView"; } };

template <typename QStringLike, typename std::enable_if<
    std::is_same<QStringLike, QString>::value || std::is_same<QStringLike, QStringRef>::value,
    bool>::type = true>
inline QStringView qToStringViewIgnoringNull(const QStringLike &s) noexcept
{ return QStringView(s.data(), s.size()); }



#line 387 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringview.h"
#pragma external_header(pop)
#line 56 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"













#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"



class QCharRef;
class QRegExp;
class QRegularExpression;
class QRegularExpressionMatch;
class QString;
class QStringList;
class QTextCodec;
class QStringRef;
template <typename T> class QVector;

namespace QtPrivate {
template <bool...B> class BoolList;
}

class QLatin1String
{
public:
    constexpr inline QLatin1String() noexcept : m_size(0), m_data(nullptr) {}
    constexpr inline explicit QLatin1String(const char *s) noexcept : m_size(s ? int(strlen(s)) : 0), m_data(s) {}
    constexpr explicit QLatin1String(const char *f, const char *l)
        : QLatin1String(f, int(l - f)) {}
    constexpr inline explicit QLatin1String(const char *s, int sz) noexcept : m_size(sz), m_data(s) {}
    inline explicit QLatin1String(const QByteArray &s) noexcept : m_size(int(qstrnlen(s.constData(), s.size()))), m_data(s.constData()) {}

    constexpr const char *latin1() const noexcept { return m_data; }
    constexpr int size() const noexcept { return m_size; }
    constexpr const char *data() const noexcept { return m_data; }

    constexpr bool isNull() const noexcept { return !data(); }
    constexpr bool isEmpty() const noexcept { return !size(); }

    template <typename...Args>
    [[nodiscard]] inline QString arg(Args &&...args) const;

    constexpr QLatin1Char at(int i) const
    { return ((i >= 0) ? static_cast<void>(0) : qt_assert("i >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 108)), ((i < size()) ? static_cast<void>(0) : qt_assert("i < size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 108)), QLatin1Char(m_data[i]); }
    constexpr QLatin1Char operator[](int i) const { return at(i); }

    [[nodiscard]] constexpr QLatin1Char front() const { return at(0); }
    [[nodiscard]] constexpr QLatin1Char back() const { return at(size() - 1); }

    [[nodiscard]] int compare(QStringView other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::compareStrings(*this, other, cs); }
    [[nodiscard]] int compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::compareStrings(*this, other, cs); }
    [[nodiscard]] constexpr int compare(QChar c) const noexcept
    { return isEmpty() || front() == c ? size() - 1 : uchar(m_data[0]) - c.unicode() ; }
    [[nodiscard]] int compare(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::compareStrings(*this, QStringView(&c, 1), cs); }

    [[nodiscard]] bool startsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }
    [[nodiscard]] bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }
    [[nodiscard]] constexpr bool startsWith(QChar c) const noexcept
    { return !isEmpty() && front() == c; }
    [[nodiscard]] inline bool startsWith(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::startsWith(*this, QStringView(&c, 1), cs); }

    [[nodiscard]] bool endsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }
    [[nodiscard]] bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }
    [[nodiscard]] constexpr bool endsWith(QChar c) const noexcept
    { return !isEmpty() && back() == c; }
    [[nodiscard]] inline bool endsWith(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::endsWith(*this, QStringView(&c, 1), cs); }

    [[nodiscard]] int indexOf(QStringView s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::findString(*this, from, s, cs)); } 
    [[nodiscard]] int indexOf(QLatin1String s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::findString(*this, from, s, cs)); } 
    [[nodiscard]] inline int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::findString(*this, from, QStringView(&c, 1), cs)); } 

    [[nodiscard]] bool contains(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(s, 0, cs) != -1; }
    [[nodiscard]] bool contains(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(s, 0, cs) != -1; }
    [[nodiscard]] inline bool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(QStringView(&c, 1), 0, cs) != -1; }

    [[nodiscard]] int lastIndexOf(QStringView s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::lastIndexOf(*this, from, s, cs)); } 
    [[nodiscard]] int lastIndexOf(QLatin1String s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::lastIndexOf(*this, from, s, cs)); } 
    [[nodiscard]] inline int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::lastIndexOf(*this, from, QStringView(&c, 1), cs)); } 

    using value_type = const char;
    using reference = value_type&;
    using const_reference = reference;
    using iterator = value_type*;
    using const_iterator = iterator;
    using difference_type = int; 
    using size_type = int;       

    constexpr const_iterator begin() const noexcept { return data(); }
    constexpr const_iterator cbegin() const noexcept { return data(); }
    constexpr const_iterator end() const noexcept { return data() + size(); }
    constexpr const_iterator cend() const noexcept { return data() + size(); }

    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = reverse_iterator;

    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }

    constexpr QLatin1String mid(int pos) const
    { return ((pos >= 0) ? static_cast<void>(0) : qt_assert("pos >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 184)), ((pos <= size()) ? static_cast<void>(0) : qt_assert("pos <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 184)), QLatin1String(m_data + pos, m_size - pos); }
    constexpr QLatin1String mid(int pos, int n) const
    { return ((pos >= 0) ? static_cast<void>(0) : qt_assert("pos >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 186)), ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 186)), ((pos + n <= size()) ? static_cast<void>(0) : qt_assert("pos + n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 186)), QLatin1String(m_data + pos, n); }
    constexpr QLatin1String left(int n) const
    { return ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 188)), ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 188)), QLatin1String(m_data, n); }
    constexpr QLatin1String right(int n) const
    { return ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 190)), ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 190)), QLatin1String(m_data + m_size - n, n); }
    [[nodiscard]] constexpr QLatin1String chopped(int n) const
    { return ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 192)), ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 192)), QLatin1String(m_data, m_size - n); }

    constexpr void chop(int n)
    { ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 195)); ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 195)); m_size -= n; }
    constexpr void truncate(int n)
    { ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 197)); ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 197)); m_size = n; }

    [[nodiscard]] QLatin1String trimmed() const noexcept { return QtPrivate::trimmed(*this); }

    inline bool operator==(const QString &s) const noexcept;
    inline bool operator!=(const QString &s) const noexcept;
    inline bool operator>(const QString &s) const noexcept;
    inline bool operator<(const QString &s) const noexcept;
    inline bool operator>=(const QString &s) const noexcept;
    inline bool operator<=(const QString &s) const noexcept;


    inline  bool operator==(const char *s) const;
    inline  bool operator!=(const char *s) const;
    inline  bool operator<(const char *s) const;
    inline  bool operator>(const char *s) const;
    inline  bool operator<=(const char *s) const;
    inline  bool operator>=(const char *s) const;

    inline  bool operator==(const QByteArray &s) const;
    inline  bool operator!=(const QByteArray &s) const;
    inline  bool operator<(const QByteArray &s) const;
    inline  bool operator>(const QByteArray &s) const;
    inline  bool operator<=(const QByteArray &s) const;
    inline  bool operator>=(const QByteArray &s) const;
#line 223 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

private:
    int m_size;
    const char *m_data;
};
template<> class QTypeInfo<QLatin1String > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QLatin1String>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QLatin1String>(), isLarge = (sizeof(QLatin1String)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QLatin1String >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QLatin1String) }; static inline const char *name() { return "QLatin1String"; } };





#line 235 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"




constexpr bool QtPrivate::isLatin1(QLatin1String) noexcept
{ return true; }




int QStringView::compare(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
{ return QtPrivate::compareStrings(*this, s, cs); }
bool QStringView::startsWith(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
{ return QtPrivate::startsWith(*this, s, cs); }
bool QStringView::endsWith(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
{ return QtPrivate::endsWith(*this, s, cs); }
qsizetype QStringView::indexOf(QLatin1String s, qsizetype from, Qt::CaseSensitivity cs) const noexcept
{ return QtPrivate::findString(*this, from, s, cs); }
bool QStringView::contains(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
{ return indexOf(s, 0, cs) != qsizetype(-1); }
qsizetype QStringView::lastIndexOf(QLatin1String s, qsizetype from, Qt::CaseSensitivity cs) const noexcept
{ return QtPrivate::lastIndexOf(*this, from, s, cs); }

class __declspec(dllimport) QString
{
public:
    typedef QStringData Data;

    inline QString() noexcept;
    explicit QString(const QChar *unicode, int size = -1);
    QString(QChar c);
    QString(int size, QChar c);
    inline QString(QLatin1String latin1);
    inline QString(const QString &) noexcept;
    inline ~QString();
    QString &operator=(QChar c);
    QString &operator=(const QString &) noexcept;
    QString &operator=(QLatin1String latin1);
    inline QString(QString && other) noexcept : d(other.d) { other.d = Data::sharedNull(); }
    inline QString &operator=(QString &&other) noexcept
    { qSwap(d, other.d); return *this; }
    inline void swap(QString &other) noexcept { qSwap(d, other.d); }
    inline int size() const { return d->size; }
    inline int count() const { return d->size; }
    inline int length() const;
    inline bool isEmpty() const;
    void resize(int size);
    void resize(int size, QChar fillChar);

    QString &fill(QChar c, int size = -1);
    void truncate(int pos);
    void chop(int n);

    int capacity() const;
    inline void reserve(int size);
    inline void squeeze();

    inline const QChar *unicode() const;
    inline QChar *data();
    inline const QChar *data() const;
    inline const QChar *constData() const;

    inline void detach();
    inline bool isDetached() const;
    inline bool isSharedWith(const QString &other) const { return d == other.d; }
    void clear();

    inline const QChar at(int i) const;
    const QChar operator[](int i) const;
    [[nodiscard]] QCharRef operator[](int i);
    const QChar operator[](uint i) const;
    [[nodiscard]] QCharRef operator[](uint i);

    [[nodiscard]] inline QChar front() const { return at(0); }
    [[nodiscard]] inline QCharRef front();
    [[nodiscard]] inline QChar back() const { return at(size() - 1); }
    [[nodiscard]] inline QCharRef back();

    [[nodiscard]] QString arg(qlonglong a, int fieldwidth=0, int base=10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(qulonglong a, int fieldwidth=0, int base=10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(long a, int fieldwidth=0, int base=10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(ulong a, int fieldwidth=0, int base=10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(int a, int fieldWidth = 0, int base = 10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(uint a, int fieldWidth = 0, int base = 10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(short a, int fieldWidth = 0, int base = 10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(ushort a, int fieldWidth = 0, int base = 10,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(char a, int fieldWidth = 0,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(QChar a, int fieldWidth = 0,
                QChar fillChar = QLatin1Char(' ')) const;

    [[nodiscard]] QString arg(const QString &a, int fieldWidth = 0,
                QChar fillChar = QLatin1Char(' ')) const;
#line 339 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] QString arg(QStringView a, int fieldWidth = 0,
                QChar fillChar = QLatin1Char(' ')) const;
    [[nodiscard]] QString arg(QLatin1String a, int fieldWidth = 0,
                QChar fillChar = QLatin1Char(' ')) const;

    [[nodiscard]] QString arg(const QString &a1, const QString &a2) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6,
                const QString &a7) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6,
                const QString &a7, const QString &a8) const;
    [[nodiscard]] QString arg(const QString &a1, const QString &a2, const QString &a3,
                const QString &a4, const QString &a5, const QString &a6,
                const QString &a7, const QString &a8, const QString &a9) const;
#line 362 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
private:
    template <typename T>
    struct is_convertible_to_view_or_qstring_helper
        : std::integral_constant<bool,
            std::is_convertible<T, QString>::value ||
            std::is_convertible<T, QStringView>::value ||
            std::is_convertible<T, QLatin1String>::value> {};
    template <typename T>
    struct is_convertible_to_view_or_qstring
        : is_convertible_to_view_or_qstring_helper<typename std::decay<T>::type> {};
public:
    template <typename...Args>
    [[nodiscard]]



    typename std::enable_if<
        sizeof...(Args) >= 2 && std::is_same<
            QtPrivate::BoolList<is_convertible_to_view_or_qstring<Args>::value..., true>,
            QtPrivate::BoolList<true, is_convertible_to_view_or_qstring<Args>::value...>
        >::value,
        QString
    >::type
#line 386 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    arg(Args &&...args) const
    { return qToStringViewIgnoringNull(*this).arg(std::forward<Args>(args)...); }






#line 395 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    static QString vasprintf(const char *format, va_list ap) ;
    static QString asprintf(const char *format, ...) ;

    int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int indexOf(QLatin1String s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int indexOf(const QStringRef &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 404 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] int indexOf(QStringView s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::findString(*this, from, s, cs)); } 
    int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int lastIndexOf(QLatin1String s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int lastIndexOf(const QStringRef &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 412 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    [[nodiscard]] int lastIndexOf(QStringView s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::lastIndexOf(*this, from, s, cs)); } 

    inline bool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    inline bool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline bool contains(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 421 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    inline bool contains(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline bool contains(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;


    int indexOf(const QRegExp &, int from = 0) const;
    int lastIndexOf(const QRegExp &, int from = -1) const;
    inline bool contains(const QRegExp &rx) const { return indexOf(rx) != -1; }
    int count(const QRegExp &) const;

    int indexOf(QRegExp &, int from = 0) const;
    int lastIndexOf(QRegExp &, int from = -1) const;
    inline bool contains(QRegExp &rx) const { return indexOf(rx) != -1; }
#line 437 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"


    int indexOf(const QRegularExpression &re, int from = 0) const;
    int indexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const; 
    int lastIndexOf(const QRegularExpression &re, int from = -1) const;
    int lastIndexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const; 
    bool contains(const QRegularExpression &re) const;
    bool contains(const QRegularExpression &re, QRegularExpressionMatch *rmatch) const; 
    int count(const QRegularExpression &re) const;
#line 447 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    enum SectionFlag {
        SectionDefault             = 0x00,
        SectionSkipEmpty           = 0x01,
        SectionIncludeLeadingSep   = 0x02,
        SectionIncludeTrailingSep  = 0x04,
        SectionCaseInsensitiveSeps = 0x08
    };
    typedef QFlags<SectionFlag> SectionFlags;

    QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
    QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;

    QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;
#line 462 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    QString section(const QRegularExpression &re, int start, int end = -1, SectionFlags flags = SectionDefault) const;
#line 465 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] QString left(int n) const;
    [[nodiscard]] QString right(int n) const;
    [[nodiscard]] QString mid(int position, int n = -1) const;
    [[nodiscard]] QString chopped(int n) const
    { ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 469)); ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 469)); return left(size() - n); }


    [[nodiscard]] QStringRef leftRef(int n) const;
    [[nodiscard]] QStringRef rightRef(int n) const;
    [[nodiscard]] QStringRef midRef(int position, int n = -1) const;


    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 480 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] bool startsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }
    bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;


    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 489 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] bool endsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }
    bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool isUpper() const;
    bool isLower() const;

    [[nodiscard]] QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const;
    [[nodiscard]] QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const;








#line 508 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] QString toLower() const &
    { return toLower_helper(*this); }
    [[nodiscard]] QString toLower() &&
    { return toLower_helper(*this); }
    [[nodiscard]] QString toUpper() const &
    { return toUpper_helper(*this); }
    [[nodiscard]] QString toUpper() &&
    { return toUpper_helper(*this); }
    [[nodiscard]] QString toCaseFolded() const &
    { return toCaseFolded_helper(*this); }
    [[nodiscard]] QString toCaseFolded() &&
    { return toCaseFolded_helper(*this); }
    [[nodiscard]] QString trimmed() const &
    { return trimmed_helper(*this); }
    [[nodiscard]] QString trimmed() &&
    { return trimmed_helper(*this); }
    [[nodiscard]] QString simplified() const &
    { return simplified_helper(*this); }
    [[nodiscard]] QString simplified() &&
    { return simplified_helper(*this); }









#line 538 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] QString toHtmlEscaped() const;

    QString &insert(int i, QChar c);
    QString &insert(int i, const QChar *uc, int len);
    inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
    inline QString &insert(int i, const QStringRef &s);
    inline QString &insert(int i, QStringView s)
    { return insert(i, s.data(), s.length()); }
    QString &insert(int i, QLatin1String s);
    QString &append(QChar c);
    QString &append(const QChar *uc, int len);
    QString &append(const QString &s);
    QString &append(const QStringRef &s);
    QString &append(QLatin1String s);
    inline QString &append(QStringView s) { return append(s.data(), s.length()); }
    inline QString &prepend(QChar c) { return insert(0, c); }
    inline QString &prepend(const QChar *uc, int len) { return insert(0, uc, len); }
    inline QString &prepend(const QString &s) { return insert(0, s); }
    inline QString &prepend(const QStringRef &s) { return insert(0, s); }
    inline QString &prepend(QLatin1String s) { return insert(0, s); }
    inline QString &prepend(QStringView s) { return insert(0, s); }

    inline QString &operator+=(QChar c) {
        if (d->ref.isShared() || uint(d->size) + 2u > d->alloc)
            reallocData(uint(d->size) + 2u, true);
        d->data()[d->size++] = c.unicode();
        d->data()[d->size] = '\0';
        return *this;
    }

    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
    inline QString &operator+=(const QString &s) { return append(s); }
    inline QString &operator+=(const QStringRef &s) { return append(s); }
    inline QString &operator+=(QLatin1String s) { return append(s); }
    inline QString &operator+=(QStringView s) { return append(s); }

    QString &remove(int i, int len);
    QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &remove(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(int i, int len, QChar after);
    QString &replace(int i, int len, const QChar *s, int slen);
    QString &replace(int i, int len, const QString &after);
    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QLatin1String before, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QLatin1String before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QString &before, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(const QString &before, const QString &after,
                     Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QString &replace(QChar c, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    QString &replace(const QRegExp &rx, const QString &after);
    inline QString &remove(const QRegExp &rx)
    { return replace(rx, QString()); }
#line 595 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    QString &replace(const QRegularExpression &re, const QString  &after);
    inline QString &remove(const QRegularExpression &re)
    { return replace(re, QString()); }
#line 600 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
































#line 633 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

public:
    [[nodiscard]]
    QStringList split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    [[nodiscard]]
    QVector<QStringRef> splitRef(const QString &sep,
                                 Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                                 Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    [[nodiscard]]
    QStringList split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    [[nodiscard]]
    QVector<QStringRef> splitRef(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                                 Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    [[nodiscard]]
    QStringList split(const QRegExp &sep,
                      Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const;
    [[nodiscard]]
    QVector<QStringRef> splitRef(const QRegExp &sep,
                                 Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const;
#line 656 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    [[nodiscard]]
    QStringList split(const QRegularExpression &sep,
                      Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const;
    [[nodiscard]]
    QVector<QStringRef> splitRef(const QRegularExpression &sep,
                                 Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const;
#line 664 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"


    enum NormalizationForm {
        NormalizationForm_D,
        NormalizationForm_C,
        NormalizationForm_KD,
        NormalizationForm_KC
    };
    [[nodiscard]] QString normalized(NormalizationForm mode, QChar::UnicodeVersion version = QChar::Unicode_Unassigned) const;

    [[nodiscard]] QString repeated(int times) const;

    const ushort *utf16() const;


    [[nodiscard]] QByteArray toLatin1() const &
    { return toLatin1_helper(*this); }
    [[nodiscard]] QByteArray toLatin1() &&
    { return toLatin1_helper_inplace(*this); }
    [[nodiscard]] QByteArray toUtf8() const &
    { return toUtf8_helper(*this); }
    [[nodiscard]] QByteArray toUtf8() &&
    { return toUtf8_helper(*this); }
    [[nodiscard]] QByteArray toLocal8Bit() const &
    { return toLocal8Bit_helper(isNull() ? nullptr : constData(), size()); }
    [[nodiscard]] QByteArray toLocal8Bit() &&
    { return toLocal8Bit_helper(isNull() ? nullptr : constData(), size()); }




#line 696 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] QVector<uint> toUcs4() const;

    
    static inline QString fromLatin1(const char *str, int size = -1)
    {
        QStringDataPtr dataPtr = { fromLatin1_helper(str, (str && size == -1) ? int(strlen(str)) : size) };
        return QString(dataPtr);
    }
    static inline QString fromUtf8(const char *str, int size = -1)
    {
        return fromUtf8_helper(str, (str && size == -1) ? int(strlen(str)) : size);
    }
    static inline QString fromLocal8Bit(const char *str, int size = -1)
    {
        return fromLocal8Bit_helper(str, (str && size == -1) ? int(strlen(str)) : size);
    }
    static inline QString fromLatin1(const QByteArray &str)
    { return str.isNull() ? QString() : fromLatin1(str.data(), qstrnlen(str.constData(), str.size())); }
    static inline QString fromUtf8(const QByteArray &str)
    { return str.isNull() ? QString() : fromUtf8(str.data(), qstrnlen(str.constData(), str.size())); }
    static inline QString fromLocal8Bit(const QByteArray &str)
    { return str.isNull() ? QString() : fromLocal8Bit(str.data(), qstrnlen(str.constData(), str.size())); }
    static QString fromUtf16(const ushort *, int size = -1);
    static QString fromUcs4(const uint *, int size = -1);
    static QString fromRawData(const QChar *, int size);


    static QString fromUtf16(const char16_t *str, int size = -1)
    { return fromUtf16(reinterpret_cast<const ushort *>(str), size); }
    static QString fromUcs4(const char32_t *str, int size = -1)
    { return fromUcs4(reinterpret_cast<const uint *>(str), size); }
#line 728 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"








#line 737 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    inline int toWCharArray(wchar_t *array) const;
    [[nodiscard]] static inline QString fromWCharArray(const wchar_t *string, int size = -1);

    QString &setRawData(const QChar *unicode, int size);
    QString &setUnicode(const QChar *unicode, int size);
    inline QString &setUtf16(const ushort *utf16, int size);


    int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    inline int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
#line 749 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    int compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    inline int compare(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    int compare(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return compare(QStringView{&ch, 1}, cs); }

    static inline int compare(const QString &s1, const QString &s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept
    { return s1.compare(s2, cs); }

    static inline int compare(const QString &s1, QLatin1String s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept
    { return s1.compare(s2, cs); }
    static inline int compare(QLatin1String s1, const QString &s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept
    { return -s2.compare(s1, cs); }

    static int compare(const QString &s1, const QStringRef &s2,
                       Qt::CaseSensitivity = Qt::CaseSensitive) noexcept;

    int localeAwareCompare(const QString& s) const;
    static int localeAwareCompare(const QString& s1, const QString& s2)
    { return s1.localeAwareCompare(s2); }

    int localeAwareCompare(const QStringRef &s) const;
    static int localeAwareCompare(const QString& s1, const QStringRef& s2);

    
    short  toShort(bool *ok=nullptr, int base=10) const;
    ushort toUShort(bool *ok=nullptr, int base=10) const;
    int toInt(bool *ok=nullptr, int base=10) const;
    uint toUInt(bool *ok=nullptr, int base=10) const;
    long toLong(bool *ok=nullptr, int base=10) const;
    ulong toULong(bool *ok=nullptr, int base=10) const;
    qlonglong toLongLong(bool *ok=nullptr, int base=10) const;
    qulonglong toULongLong(bool *ok=nullptr, int base=10) const;
    float toFloat(bool *ok=nullptr) const;
    double toDouble(bool *ok=nullptr) const;

    QString &setNum(short, int base=10);
    QString &setNum(ushort, int base=10);
    QString &setNum(int, int base=10);
    QString &setNum(uint, int base=10);
    QString &setNum(long, int base=10);
    QString &setNum(ulong, int base=10);
    QString &setNum(qlonglong, int base=10);
    QString &setNum(qulonglong, int base=10);
    QString &setNum(float, char f='g', int prec=6);
    QString &setNum(double, char f='g', int prec=6);

    static QString number(int, int base=10);
    static QString number(uint, int base=10);
    static QString number(long, int base=10);
    static QString number(ulong, int base=10);
    static QString number(qlonglong, int base=10);
    static QString number(qulonglong, int base=10);
    static QString number(double, char f='g', int prec=6);

    friend __declspec(dllimport) bool operator==(const QString &s1, const QString &s2) noexcept;
    friend __declspec(dllimport) bool operator<(const QString &s1, const QString &s2) noexcept;
    friend inline bool operator>(const QString &s1, const QString &s2) noexcept { return s2 < s1; }
    friend inline bool operator!=(const QString &s1, const QString &s2) noexcept { return !(s1 == s2); }
    friend inline bool operator<=(const QString &s1, const QString &s2) noexcept { return !(s1 > s2); }
    friend inline bool operator>=(const QString &s1, const QString &s2) noexcept { return !(s1 < s2); }

    bool operator==(QLatin1String s) const noexcept;
    bool operator<(QLatin1String s) const noexcept;
    bool operator>(QLatin1String s) const noexcept;
    inline bool operator!=(QLatin1String s) const noexcept { return !operator==(s); }
    inline bool operator<=(QLatin1String s) const noexcept { return !operator>(s); }
    inline bool operator>=(QLatin1String s) const noexcept { return !operator<(s); }

    












#line 834 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    inline  QString(const char *ch)
        : d(fromAscii_helper(ch, ch ? int(strlen(ch)) : -1))
    {}
    inline  QString(const QByteArray &a)
        : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
    {}
    inline  QString &operator=(const char *ch)
    { return (*this = fromUtf8(ch)); }
    inline  QString &operator=(const QByteArray &a)
    { return (*this = fromUtf8(a)); }
    inline  QString &operator=(char c)
    { return (*this = QChar::fromLatin1(c)); }

    
    inline  QString &prepend(const char *s)
    { return prepend(QString::fromUtf8(s)); }
    inline  QString &prepend(const QByteArray &s)
    { return prepend(QString::fromUtf8(s)); }
    inline  QString &append(const char *s)
    { return append(QString::fromUtf8(s)); }
    inline  QString &append(const QByteArray &s)
    { return append(QString::fromUtf8(s)); }
    inline  QString &insert(int i, const char *s)
    { return insert(i, QString::fromUtf8(s)); }
    inline  QString &insert(int i, const QByteArray &s)
    { return insert(i, QString::fromUtf8(s)); }
    inline  QString &operator+=(const char *s)
    { return append(QString::fromUtf8(s)); }
    inline  QString &operator+=(const QByteArray &s)
    { return append(QString::fromUtf8(s)); }
    inline  QString &operator+=(char c)
    { return append(QChar::fromLatin1(c)); }

    inline  bool operator==(const char *s) const;
    inline  bool operator!=(const char *s) const;
    inline  bool operator<(const char *s) const;
    inline  bool operator<=(const char *s) const;
    inline  bool operator>(const char *s) const;
    inline  bool operator>=(const char *s) const;

    inline  bool operator==(const QByteArray &s) const;
    inline  bool operator!=(const QByteArray &s) const;
    inline  bool operator<(const QByteArray &s) const;
    inline  bool operator>(const QByteArray &s) const;
    inline  bool operator<=(const QByteArray &s) const;
    inline  bool operator>=(const QByteArray &s) const;

    friend inline  bool operator==(const char *s1, const QString &s2);
    friend inline  bool operator!=(const char *s1, const QString &s2);
    friend inline  bool operator<(const char *s1, const QString &s2);
    friend inline  bool operator>(const char *s1, const QString &s2);
    friend inline  bool operator<=(const char *s1, const QString &s2);
    friend inline  bool operator>=(const char *s1, const QString &s2);

    friend inline  bool operator==(const char *s1, const QStringRef &s2);
    friend inline  bool operator!=(const char *s1, const QStringRef &s2);
    friend inline  bool operator<(const char *s1, const QStringRef &s2);
    friend inline  bool operator>(const char *s1, const QStringRef &s2);
    friend inline  bool operator<=(const char *s1, const QStringRef &s2);
    friend inline  bool operator>=(const char *s1, const QStringRef &s2);
#line 896 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    typedef QChar *iterator;
    typedef const QChar *const_iterator;
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    inline iterator begin();
    inline const_iterator begin() const;
    inline const_iterator cbegin() const;
    inline const_iterator constBegin() const;
    inline iterator end();
    inline const_iterator end() const;
    inline const_iterator cend() const;
    inline const_iterator constEnd() const;
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }

    
    typedef int size_type;
    typedef qptrdiff difference_type;
    typedef const QChar & const_reference;
    typedef QChar & reference;
    typedef QChar *pointer;
    typedef const QChar *const_pointer;
    typedef QChar value_type;
    inline void push_back(QChar c) { append(c); }
    inline void push_back(const QString &s) { append(s); }
    inline void push_front(QChar c) { prepend(c); }
    inline void push_front(const QString &s) { prepend(s); }
    void shrink_to_fit() { squeeze(); }

    static inline QString fromStdString(const std::string &s);
    inline std::string toStdString() const;
    static inline QString fromStdWString(const std::wstring &s);
    inline std::wstring toStdWString() const;


    static inline QString fromStdU16String(const std::u16string &s);
    inline std::u16string toStdU16String() const;
    static inline QString fromStdU32String(const std::u32string &s);
    inline std::u32string toStdU32String() const;
#line 943 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"






#line 950 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    






#line 958 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    inline bool isNull() const { return d == Data::sharedNull(); }


    bool isSimpleText() const;
    bool isRightToLeft() const;
    [[nodiscard]] bool isValidUtf16() const noexcept
    { return QStringView(*this).isValidUtf16(); }

    QString(int size, Qt::Initialization);
    constexpr inline QString(QStringDataPtr dd) : d(dd.ptr) {}

private:







#line 978 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    Data *d;

    friend inline bool operator==(QChar, const QString &) noexcept;
    friend inline bool operator< (QChar, const QString &) noexcept;
    friend inline bool operator> (QChar, const QString &) noexcept;
    friend inline bool operator==(QChar, const QStringRef &) noexcept;
    friend inline bool operator< (QChar, const QStringRef &) noexcept;
    friend inline bool operator> (QChar, const QStringRef &) noexcept;
    friend inline bool operator==(QChar, QLatin1String) noexcept;
    friend inline bool operator< (QChar, QLatin1String) noexcept;
    friend inline bool operator> (QChar, QLatin1String) noexcept;

    void reallocData(uint alloc, bool grow = false);

    void expand(int i);
    QString multiArg(int numArgs, const QString **args) const;
#line 996 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    static int compare_helper(const QChar *data1, int length1,
                              const QChar *data2, int length2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
    static int compare_helper(const QChar *data1, int length1,
                              const char *data2, int length2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
    static int compare_helper(const QChar *data1, int length1,
                              QLatin1String s2,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
    static int localeAwareCompare_helper(const QChar *data1, int length1,
                                         const QChar *data2, int length2);
    static QString toLower_helper(const QString &str);
    static QString toLower_helper(QString &str);
    static QString toUpper_helper(const QString &str);
    static QString toUpper_helper(QString &str);
    static QString toCaseFolded_helper(const QString &str);
    static QString toCaseFolded_helper(QString &str);
    static QString trimmed_helper(const QString &str);
    static QString trimmed_helper(QString &str);
    static QString simplified_helper(const QString &str);
    static QString simplified_helper(QString &str);
    static Data *fromLatin1_helper(const char *str, int size = -1);
    static Data *fromAscii_helper(const char *str, int size = -1);
    static QString fromUtf8_helper(const char *str, int size);
    static QString fromLocal8Bit_helper(const char *, int size);
    static QByteArray toLatin1_helper(const QString &);
    static QByteArray toLatin1_helper_inplace(QString &);
    static QByteArray toUtf8_helper(const QString &);
    static QByteArray toLocal8Bit_helper(const QChar *data, int size);
    static int toUcs4_helper(const ushort *uc, int length, uint *out);
    static qlonglong toIntegral_helper(const QChar *data, int len, bool *ok, int base);
    static qulonglong toIntegral_helper(const QChar *data, uint len, bool *ok, int base);
    void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen);
    friend class QCharRef;
    friend class QTextCodec;
    friend class QStringRef;
    friend class QStringView;
    friend class QByteArray;
    friend class QCollator;
    friend struct QAbstractConcatenable;

    template <typename T> static
    T toIntegral_helper(const QChar *data, int len, bool *ok, int base)
    {
        using Int64 = typename std::conditional<std::is_unsigned<T>::value, qulonglong, qlonglong>::type;
        using Int32 = typename std::conditional<std::is_unsigned<T>::value, uint, int>::type;

        
        Int64 val = toIntegral_helper(data, Int32(len), ok, base);
        if (T(val) != val) {
            if (ok)
                *ok = false;
            val = 0;
        }
        return T(val);
    }

public:
    typedef Data * DataPtr;
    inline DataPtr &data_ptr() { return d; }
};




QString QStringView::toString() const
{ return ((size() == length()) ? static_cast<void>(0) : qt_assert("size() == length()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1062)), QString(data(), length()); }




inline QString::QString(QLatin1String aLatin1) : d(fromLatin1_helper(aLatin1.latin1(), aLatin1.size()))
{ }
inline int QString::length() const
{ return d->size; }
inline const QChar QString::at(int i) const
{ ((uint(i) < uint(size())) ? static_cast<void>(0) : qt_assert("uint(i) < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1072)); return QChar(d->data()[i]); }
inline const QChar QString::operator[](int i) const
{ ((uint(i) < uint(size())) ? static_cast<void>(0) : qt_assert("uint(i) < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1074)); return QChar(d->data()[i]); }
inline const QChar QString::operator[](uint i) const
{ ((i < uint(size())) ? static_cast<void>(0) : qt_assert("i < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1076)); return QChar(d->data()[i]); }
inline bool QString::isEmpty() const
{ return d->size == 0; }
inline const QChar *QString::unicode() const
{ return reinterpret_cast<const QChar*>(d->data()); }
inline const QChar *QString::data() const
{ return reinterpret_cast<const QChar*>(d->data()); }
inline QChar *QString::data()
{ detach(); return reinterpret_cast<QChar*>(d->data()); }
inline const QChar *QString::constData() const
{ return reinterpret_cast<const QChar*>(d->data()); }
inline void QString::detach()
{ if (d->ref.isShared() || (d->offset != sizeof(QStringData))) reallocData(uint(d->size) + 1u); }
inline bool QString::isDetached() const
{ return !d->ref.isShared(); }
inline void QString::clear()
{ if (!isNull()) *this = QString(); }
inline QString::QString(const QString &other) noexcept : d(other.d)
{ ((&other != this) ? static_cast<void>(0) : qt_assert("&other != this", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1094)); d->ref.ref(); }
inline int QString::capacity() const
{ return d->alloc ? d->alloc - 1 : 0; }
inline QString &QString::setNum(short n, int base)
{ return setNum(qlonglong(n), base); }
inline QString &QString::setNum(ushort n, int base)
{ return setNum(qulonglong(n), base); }
inline QString &QString::setNum(int n, int base)
{ return setNum(qlonglong(n), base); }
inline QString &QString::setNum(uint n, int base)
{ return setNum(qulonglong(n), base); }
inline QString &QString::setNum(long n, int base)
{ return setNum(qlonglong(n), base); }
inline QString &QString::setNum(ulong n, int base)
{ return setNum(qulonglong(n), base); }
inline QString &QString::setNum(float n, char f, int prec)
{ return setNum(double(n),f,prec); }
inline QString QString::arg(int a, int fieldWidth, int base, QChar fillChar) const
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(uint a, int fieldWidth, int base, QChar fillChar) const
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(long a, int fieldWidth, int base, QChar fillChar) const
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(ulong a, int fieldWidth, int base, QChar fillChar) const
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(short a, int fieldWidth, int base, QChar fillChar) const
{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
inline QString QString::arg(ushort a, int fieldWidth, int base, QChar fillChar) const
{ return arg(qulonglong(a), fieldWidth, base, fillChar); }

inline QString QString::arg(const QString &a1, const QString &a2) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3, a4); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3, a4, a5); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3, a4, a5, a6); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6,
                            const QString &a7) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3, a4, a5, a6, a7); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6,
                            const QString &a7, const QString &a8) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3, a4, a5, a6, a7, a8); }
inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
                            const QString &a4, const QString &a5, const QString &a6,
                            const QString &a7, const QString &a8, const QString &a9) const
{ return qToStringViewIgnoringNull(*this).arg(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
#line 1150 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const
{ return section(QString(asep), astart, aend, aflags); }

__pragma(warning(push))
__pragma(warning(disable: 4127))   
   

inline int QString::toWCharArray(wchar_t *array) const
{
    return qToStringViewIgnoringNull(*this).toWCharArray(array);
}

int QStringView::toWCharArray(wchar_t *array) const
{
    if (sizeof(wchar_t) == sizeof(QChar)) {
        if (auto src = data())
            memcpy(array, src, sizeof(QChar) * size());
        return int(size());     
    } else {
        return QString::toUcs4_helper(reinterpret_cast<const ushort *>(data()), int(size()),
                                      reinterpret_cast<uint *>(array));
    }
}

__pragma(warning(pop))

inline QString QString::fromWCharArray(const wchar_t *string, int size)
{
    return sizeof(wchar_t) == sizeof(QChar) ? fromUtf16(reinterpret_cast<const ushort *>(string), size)
                                            : fromUcs4(reinterpret_cast<const uint *>(string), size);
}

class

__declspec(dllimport)
#line 1187 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
QCharRef { 
    QString &s;
    int i;
    inline QCharRef(QString &str, int idx)
        : s(str),i(idx) {}
    friend class QString;
public:
    QCharRef(const QCharRef &) = default;

    

    
    inline operator QChar() const
    {
        using namespace QtPrivate::DeprecatedRefClassBehavior;
        if ((i < s.d->size))
            return QChar(s.d->data()[i]);

        warn(WarningType::OutOfRange, EmittingClass::QCharRef);
#line 1207 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
        return QChar();
    }
    inline QCharRef &operator=(QChar c)
    {
        using namespace QtPrivate::DeprecatedRefClassBehavior;
        if ((i >= s.d->size)) {

            warn(WarningType::OutOfRange, EmittingClass::QCharRef);
#line 1216 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
            s.resize(i + 1, QLatin1Char(' '));
        } else {

            if ((!s.isDetached()))
                warn(WarningType::DelayedDetach, EmittingClass::QCharRef);
#line 1222 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
            s.detach();
        }
        s.d->data()[i] = c.unicode();
        return *this;
    }

    

    inline  QCharRef &operator=(char c)
    { return operator=(QChar::fromLatin1(c)); }
    inline  QCharRef &operator=(uchar c)
    { return operator=(QChar::fromLatin1(c)); }




#line 1239 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); }
    inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); }
    inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); }
    inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); }
    inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); }

    
    inline bool isNull() const { return QChar(*this).isNull(); }
    inline bool isPrint() const { return QChar(*this).isPrint(); }
    inline bool isPunct() const { return QChar(*this).isPunct(); }
    inline bool isSpace() const { return QChar(*this).isSpace(); }
    inline bool isMark() const { return QChar(*this).isMark(); }
    inline bool isLetter() const { return QChar(*this).isLetter(); }
    inline bool isNumber() const { return QChar(*this).isNumber(); }
    inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); }
    inline bool isDigit() const { return QChar(*this).isDigit(); }
    inline bool isLower() const { return QChar(*this).isLower(); }
    inline bool isUpper() const { return QChar(*this).isUpper(); }
    inline bool isTitleCase() const { return QChar(*this).isTitleCase(); }

    inline int digitValue() const { return QChar(*this).digitValue(); }
    QChar toLower() const { return QChar(*this).toLower(); }
    QChar toUpper() const { return QChar(*this).toUpper(); }
    QChar toTitleCase () const { return QChar(*this).toTitleCase(); }

    QChar::Category category() const { return QChar(*this).category(); }
    QChar::Direction direction() const { return QChar(*this).direction(); }
    QChar::JoiningType joiningType() const { return QChar(*this).joiningType(); }













#line 1281 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    bool hasMirrored() const { return QChar(*this).hasMirrored(); }
    QChar mirroredChar() const { return QChar(*this).mirroredChar(); }
    QString decomposition() const { return QChar(*this).decomposition(); }
    QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); }
    uchar combiningClass() const { return QChar(*this).combiningClass(); }

    inline QChar::Script script() const { return QChar(*this).script(); }

    QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); }

    inline uchar cell() const { return QChar(*this).cell(); }
    inline uchar row() const { return QChar(*this).row(); }
    inline void setCell(uchar cell);
    inline void setRow(uchar row);



#line 1299 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    char toLatin1() const { return QChar(*this).toLatin1(); }
    ushort unicode() const { return QChar(*this).unicode(); }
    ushort& unicode() { return s.data()[i].unicode(); }

};
template<> class QTypeInfo<QCharRef > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QCharRef>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QCharRef>(), isLarge = (sizeof(QCharRef)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QCharRef >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QCharRef) }; static inline const char *name() { return "QCharRef"; } };

inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }


inline QString::QString() noexcept : d(Data::sharedNull()) {}
inline QString::~QString() { if (!d->ref.deref()) Data::deallocate(d); }

inline void QString::reserve(int asize)
{
    if (d->ref.isShared() || uint(asize) >= d->alloc)
        reallocData(qMax(asize, d->size) + 1u);

    if (!d->capacityReserved) {
        
        d->capacityReserved = true;
    }
}

inline void QString::squeeze()
{
    if (d->ref.isShared() || uint(d->size) + 1u < d->alloc)
        reallocData(uint(d->size) + 1u);

    if (d->capacityReserved) {
        
        
        d->capacityReserved = false;
    }
}

inline QString &QString::setUtf16(const ushort *autf16, int asize)
{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
inline QCharRef QString::operator[](int i)
{ ((i >= 0) ? static_cast<void>(0) : qt_assert("i >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1339)); detach(); return QCharRef(*this, i); }
inline QCharRef QString::operator[](uint i)
{  detach(); return QCharRef(*this, i); }
inline QCharRef QString::front() { return operator[](0); }
inline QCharRef QString::back() { return operator[](size() - 1); }
inline QString::iterator QString::begin()
{ detach(); return reinterpret_cast<QChar*>(d->data()); }
inline QString::const_iterator QString::begin() const
{ return reinterpret_cast<const QChar*>(d->data()); }
inline QString::const_iterator QString::cbegin() const
{ return reinterpret_cast<const QChar*>(d->data()); }
inline QString::const_iterator QString::constBegin() const
{ return reinterpret_cast<const QChar*>(d->data()); }
inline QString::iterator QString::end()
{ detach(); return reinterpret_cast<QChar*>(d->data() + d->size); }
inline QString::const_iterator QString::end() const
{ return reinterpret_cast<const QChar*>(d->data() + d->size); }
inline QString::const_iterator QString::cend() const
{ return reinterpret_cast<const QChar*>(d->data() + d->size); }
inline QString::const_iterator QString::constEnd() const
{ return reinterpret_cast<const QChar*>(d->data() + d->size); }

inline bool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
{ return indexOf(s, 0, cs) != -1; }
inline bool QString::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
{ return indexOf(s, 0, cs) != -1; }
#line 1366 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
inline bool QString::contains(QLatin1String s, Qt::CaseSensitivity cs) const
{ return indexOf(s, 0, cs) != -1; }
inline bool QString::contains(QChar c, Qt::CaseSensitivity cs) const
{ return indexOf(c, 0, cs) != -1; }
inline bool QString::contains(QStringView s, Qt::CaseSensitivity cs) const noexcept
{ return indexOf(s, 0, cs) != -1; }












#line 1385 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

inline bool operator==(QLatin1String s1, QLatin1String s2) noexcept
{ return s1.size() == s2.size() && (!s1.size() || !memcmp(s1.latin1(), s2.latin1(), s1.size())); }
inline bool operator!=(QLatin1String s1, QLatin1String s2) noexcept
{ return !operator==(s1, s2); }
inline bool operator<(QLatin1String s1, QLatin1String s2) noexcept
{
    const int len = qMin(s1.size(), s2.size());
    const int r = len ? memcmp(s1.latin1(), s2.latin1(), len) : 0;
    return r < 0 || (r == 0 && s1.size() < s2.size());
}
inline bool operator>(QLatin1String s1, QLatin1String s2) noexcept
{ return operator<(s2, s1); }
inline bool operator<=(QLatin1String s1, QLatin1String s2) noexcept
{ return !operator>(s1, s2); }
inline bool operator>=(QLatin1String s1, QLatin1String s2) noexcept
{ return !operator<(s1, s2); }

inline bool QLatin1String::operator==(const QString &s) const noexcept
{ return s == *this; }
inline bool QLatin1String::operator!=(const QString &s) const noexcept
{ return s != *this; }
inline bool QLatin1String::operator>(const QString &s) const noexcept
{ return s < *this; }
inline bool QLatin1String::operator<(const QString &s) const noexcept
{ return s > *this; }
inline bool QLatin1String::operator>=(const QString &s) const noexcept
{ return s <= *this; }
inline bool QLatin1String::operator<=(const QString &s) const noexcept
{ return s >= *this; }


inline bool QString::operator==(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) == 0; }
inline bool QString::operator!=(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) != 0; }
inline bool QString::operator<(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) < 0; }
inline bool QString::operator>(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) > 0; }
inline bool QString::operator<=(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) <= 0; }
inline bool QString::operator>=(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) >= 0; }

inline  bool operator==(const char *s1, const QString &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) == 0; }
inline  bool operator!=(const char *s1, const QString &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) != 0; }
inline  bool operator<(const char *s1, const QString &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) > 0; }
inline  bool operator>(const char *s1, const QString &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) < 0; }
inline  bool operator<=(const char *s1, const QString &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) >= 0; }
inline  bool operator>=(const char *s1, const QString &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) <= 0; }

inline  bool operator==(const char *s1, QLatin1String s2)
{ return QString::fromUtf8(s1) == s2; }
inline  bool operator!=(const char *s1, QLatin1String s2)
{ return QString::fromUtf8(s1) != s2; }
inline  bool operator<(const char *s1, QLatin1String s2)
{ return (QString::fromUtf8(s1) < s2); }
inline  bool operator>(const char *s1, QLatin1String s2)
{ return (QString::fromUtf8(s1) > s2); }
inline  bool operator<=(const char *s1, QLatin1String s2)
{ return (QString::fromUtf8(s1) <= s2); }
inline  bool operator>=(const char *s1, QLatin1String s2)
{ return (QString::fromUtf8(s1) >= s2); }

inline  bool QLatin1String::operator==(const char *s) const
{ return QString::fromUtf8(s) == *this; }
inline  bool QLatin1String::operator!=(const char *s) const
{ return QString::fromUtf8(s) != *this; }
inline  bool QLatin1String::operator<(const char *s) const
{ return QString::fromUtf8(s) > *this; }
inline  bool QLatin1String::operator>(const char *s) const
{ return QString::fromUtf8(s) < *this; }
inline  bool QLatin1String::operator<=(const char *s) const
{ return QString::fromUtf8(s) >= *this; }
inline  bool QLatin1String::operator>=(const char *s) const
{ return QString::fromUtf8(s) <= *this; }

inline  bool QLatin1String::operator==(const QByteArray &s) const
{ return QString::fromUtf8(s) == *this; }
inline  bool QLatin1String::operator!=(const QByteArray &s) const
{ return QString::fromUtf8(s) != *this; }
inline  bool QLatin1String::operator<(const QByteArray &s) const
{ return QString::fromUtf8(s) > *this; }
inline  bool QLatin1String::operator>(const QByteArray &s) const
{ return QString::fromUtf8(s) < *this; }
inline  bool QLatin1String::operator<=(const QByteArray &s) const
{ return QString::fromUtf8(s) >= *this; }
inline  bool QLatin1String::operator>=(const QByteArray &s) const
{ return QString::fromUtf8(s) <= *this; }

inline  bool QString::operator==(const QByteArray &s) const
{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) == 0; }
inline  bool QString::operator!=(const QByteArray &s) const
{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) != 0; }
inline  bool QString::operator<(const QByteArray &s) const
{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) < 0; }
inline  bool QString::operator>(const QByteArray &s) const
{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) > 0; }
inline  bool QString::operator<=(const QByteArray &s) const
{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) <= 0; }
inline  bool QString::operator>=(const QByteArray &s) const
{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) >= 0; }

inline bool QByteArray::operator==(const QString &s) const
{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) == 0; }
inline bool QByteArray::operator!=(const QString &s) const
{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) != 0; }
inline bool QByteArray::operator<(const QString &s) const
{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) > 0; }
inline bool QByteArray::operator>(const QString &s) const
{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) < 0; }
inline bool QByteArray::operator<=(const QString &s) const
{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) >= 0; }
inline bool QByteArray::operator>=(const QString &s) const
{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) <= 0; }

#line 1509 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"


















#line 1528 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"






















#line 1551 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

inline std::string QString::toStdString() const
{ return toUtf8().toStdString(); }

inline QString QString::fromStdString(const std::string &s)
{ return fromUtf8(s.data(), int(s.size())); }

inline std::wstring QString::toStdWString() const
{
    std::wstring str;
    str.resize(length());

    str.resize(toWCharArray(str.data()));



#line 1568 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    return str;
}

inline QString QString::fromStdWString(const std::wstring &s)
{ return fromWCharArray(s.data(), int(s.size())); }


inline QString QString::fromStdU16String(const std::u16string &s)
{ return fromUtf16(s.data(), int(s.size())); }

inline std::u16string QString::toStdU16String() const
{ return std::u16string(reinterpret_cast<const char16_t*>(utf16()), length()); }

inline QString QString::fromStdU32String(const std::u32string &s)
{ return fromUcs4(s.data(), int(s.size())); }

inline std::u32string QString::toStdU32String() const
{
    std::u32string u32str(length(), char32_t(0));
    int len = toUcs4_helper(d->data(), length(), reinterpret_cast<uint*>(&u32str[0]));
    u32str.resize(len);
    return u32str;
}
#line 1592 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"


__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QString &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QString &);
#line 1597 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

template<> class QTypeInfo<QString > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QString>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QString>(), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QString >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QString) }; static inline const char *name() { return "QString"; } }; inline void swap(QString &value1, QString &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
constexpr inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) noexcept { return QFlags<QString::SectionFlags::enum_type>(f1) | f2; } constexpr inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QFlags<QString::SectionFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }


class __declspec(dllimport) QStringRef {
    const QString *m_string;
    int m_position;
    int m_size;
public:
    typedef QString::size_type size_type;
    typedef QString::value_type value_type;
    typedef const QChar *const_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef QString::const_pointer const_pointer;
    typedef QString::const_reference const_reference;

    
    inline QStringRef() : m_string(nullptr), m_position(0), m_size(0) {}
    inline QStringRef(const QString *string, int position, int size);
    inline QStringRef(const QString *string);


    
    QStringRef(const QStringRef &other) noexcept
        :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size)
        {}
    QStringRef(QStringRef &&other) noexcept : m_string(other.m_string), m_position(other.m_position), m_size(other.m_size) {}
    QStringRef &operator=(QStringRef &&other) noexcept { return *this = other; }
    QStringRef &operator=(const QStringRef &other) noexcept
    {
        m_string = other.m_string; m_position = other.m_position;
        m_size = other.m_size; return *this;
    }
    inline ~QStringRef(){}
#line 1633 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    inline const QString *string() const { return m_string; }
    inline int position() const { return m_position; }
    inline int size() const { return m_size; }
    inline int count() const { return m_size; }
    inline int length() const { return m_size; }


    int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 1644 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] int indexOf(QStringView s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::findString(*this, from, s, cs)); } 
    int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    int lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 1652 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    [[nodiscard]] int lastIndexOf(QStringView s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return int(QtPrivate::lastIndexOf(*this, from, s, cs)); } 


    inline bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline bool contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 1661 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    inline bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline bool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline bool contains(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;








#line 1677 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    [[nodiscard]]
    QVector<QStringRef> split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    [[nodiscard]]
    QVector<QStringRef> split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts,
                              Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    [[nodiscard]] QStringRef left(int n) const;
    [[nodiscard]] QStringRef right(int n) const;
    [[nodiscard]] QStringRef mid(int pos, int n = -1) const;
    [[nodiscard]] QStringRef chopped(int n) const
    { ((n >= 0) ? static_cast<void>(0) : qt_assert("n >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1689)); ((n <= size()) ? static_cast<void>(0) : qt_assert("n <= size()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1689)); return left(size() - n); }

    void truncate(int pos) noexcept { m_size = qBound(0, pos, m_size); }
    void chop(int n) noexcept
    {
        if (n >= m_size)
            m_size = 0;
        else if (n > 0)
            m_size -= n;
    }

    bool isRightToLeft() const;

    [[nodiscard]] bool startsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }
    bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool startsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 1710 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    [[nodiscard]] bool endsWith(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }
    bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    bool endsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 1719 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    inline QStringRef &operator=(const QString *string);

    inline const QChar *unicode() const
    {
        if (!m_string)
            return reinterpret_cast<const QChar *>(QString::Data::sharedNull()->data());
        return m_string->unicode() + m_position;
    }
    inline const QChar *data() const { return unicode(); }
    inline const QChar *constData() const {  return unicode(); }

    inline const_iterator begin() const { return unicode(); }
    inline const_iterator cbegin() const { return unicode(); }
    inline const_iterator constBegin() const { return unicode(); }
    inline const_iterator end() const { return unicode() + size(); }
    inline const_iterator cend() const { return unicode() + size(); }
    inline const_iterator constEnd() const { return unicode() + size(); }
    inline const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    inline const_reverse_iterator crbegin() const { return rbegin(); }
    inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
    inline const_reverse_iterator crend() const { return rend(); }




#line 1746 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    [[nodiscard]] QByteArray toLatin1() const;
    [[nodiscard]] QByteArray toUtf8() const;
    [[nodiscard]] QByteArray toLocal8Bit() const;
    [[nodiscard]] QVector<uint> toUcs4() const;

    inline void clear() { m_string = nullptr; m_position = m_size = 0; }
    QString toString() const;
    inline bool isEmpty() const { return m_size == 0; }
    inline bool isNull() const { return m_string == nullptr || m_string->isNull(); }

    QStringRef appendTo(QString *string) const;

    inline const QChar at(int i) const
        { ((uint(i) < uint(size())) ? static_cast<void>(0) : qt_assert("uint(i) < uint(size())", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h", 1759)); return m_string->at(i + m_position); }
    QChar operator[](int i) const { return at(i); }
    [[nodiscard]] QChar front() const { return at(0); }
    [[nodiscard]] QChar back() const { return at(size() - 1); }


    
    inline  bool operator==(const char *s) const;
    inline  bool operator!=(const char *s) const;
    inline  bool operator<(const char *s) const;
    inline  bool operator<=(const char *s) const;
    inline  bool operator>(const char *s) const;
    inline  bool operator>=(const char *s) const;
#line 1773 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

    int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
    int compare(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::compareStrings(*this, QStringView(&c, 1), cs); }
    int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;

    int compare(const QByteArray &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
    { return QString::compare_helper(unicode(), size(), s.data(), qstrnlen(s.data(), s.size()), cs); }
#line 1783 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
    static int compare(const QStringRef &s1, const QString &s2,
                       Qt::CaseSensitivity = Qt::CaseSensitive) noexcept;
    static int compare(const QStringRef &s1, const QStringRef &s2,
                       Qt::CaseSensitivity = Qt::CaseSensitive) noexcept;
    static int compare(const QStringRef &s1, QLatin1String s2,
                       Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;

    int localeAwareCompare(const QString &s) const;
    int localeAwareCompare(const QStringRef &s) const;
    int localeAwareCompare(QStringView str) const;
    static int localeAwareCompare(const QStringRef &s1, const QString &s2);
    static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2);
    static int localeAwareCompare(QStringView s1, QStringView s2);

    [[nodiscard]] QStringRef trimmed() const;
    short  toShort(bool *ok = nullptr, int base = 10) const;
    ushort toUShort(bool *ok = nullptr, int base = 10) const;
    int toInt(bool *ok = nullptr, int base = 10) const;
    uint toUInt(bool *ok = nullptr, int base = 10) const;
    long toLong(bool *ok = nullptr, int base = 10) const;
    ulong toULong(bool *ok = nullptr, int base = 10) const;
    qlonglong toLongLong(bool *ok = nullptr, int base = 10) const;
    qulonglong toULongLong(bool *ok = nullptr, int base = 10) const;
    float toFloat(bool *ok = nullptr) const;
    double toDouble(bool *ok = nullptr) const;
};
template<> class QTypeInfo<QStringRef > { public: enum { isSpecialized = true, isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QStringRef>(), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QStringRef>(), isLarge = (sizeof(QStringRef)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QStringRef >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QStringRef) }; static inline const char *name() { return "QStringRef"; } };

inline QStringRef &QStringRef::operator=(const QString *aString)
{ m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; }

inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
        :m_string(aString), m_position(aPosition), m_size(aSize){}

inline QStringRef::QStringRef(const QString *aString)
    :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}


__declspec(dllimport) bool operator==(const QStringRef &s1, const QStringRef &s2) noexcept;
inline bool operator!=(const QStringRef &s1, const QStringRef &s2) noexcept
{ return !(s1 == s2); }
__declspec(dllimport) bool operator<(const QStringRef &s1, const QStringRef &s2) noexcept;
inline bool operator>(const QStringRef &s1, const QStringRef &s2) noexcept
{ return s2 < s1; }
inline bool operator<=(const QStringRef &s1, const QStringRef &s2) noexcept
{ return !(s1 > s2); }
inline bool operator>=(const QStringRef &s1, const QStringRef &s2) noexcept
{ return !(s1 < s2); }


__declspec(dllimport) bool operator==(const QString &lhs, const QStringRef &rhs) noexcept;
inline bool operator!=(const QString &lhs, const QStringRef &rhs) noexcept { return lhs.compare(rhs) != 0; }
inline bool operator< (const QString &lhs, const QStringRef &rhs) noexcept { return lhs.compare(rhs) <  0; }
inline bool operator> (const QString &lhs, const QStringRef &rhs) noexcept { return lhs.compare(rhs) >  0; }
inline bool operator<=(const QString &lhs, const QStringRef &rhs) noexcept { return lhs.compare(rhs) <= 0; }
inline bool operator>=(const QString &lhs, const QStringRef &rhs) noexcept { return lhs.compare(rhs) >= 0; }

inline bool operator==(const QStringRef &lhs, const QString &rhs) noexcept { return rhs == lhs; }
inline bool operator!=(const QStringRef &lhs, const QString &rhs) noexcept { return rhs != lhs; }
inline bool operator< (const QStringRef &lhs, const QString &rhs) noexcept { return rhs >  lhs; }
inline bool operator> (const QStringRef &lhs, const QString &rhs) noexcept { return rhs <  lhs; }
inline bool operator<=(const QStringRef &lhs, const QString &rhs) noexcept { return rhs >= lhs; }
inline bool operator>=(const QStringRef &lhs, const QString &rhs) noexcept { return rhs <= lhs; }


inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const noexcept
{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
#line 1851 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
inline int QString::compare(QStringView s, Qt::CaseSensitivity cs) const noexcept
{ return -s.compare(*this, cs); }
inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) noexcept
{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const noexcept
{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const noexcept
{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
{ return QString::compare_helper(constData(), length(), s, cs); }
inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) noexcept
{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs) noexcept
{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs) noexcept
{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }


__declspec(dllimport) bool operator==(QLatin1String lhs, const QStringRef &rhs) noexcept;
inline bool operator!=(QLatin1String lhs, const QStringRef &rhs) noexcept { return rhs.compare(lhs) != 0; }
inline bool operator< (QLatin1String lhs, const QStringRef &rhs) noexcept { return rhs.compare(lhs) >  0; }
inline bool operator> (QLatin1String lhs, const QStringRef &rhs) noexcept { return rhs.compare(lhs) <  0; }
inline bool operator<=(QLatin1String lhs, const QStringRef &rhs) noexcept { return rhs.compare(lhs) >= 0; }
inline bool operator>=(QLatin1String lhs, const QStringRef &rhs) noexcept { return rhs.compare(lhs) <= 0; }

inline bool operator==(const QStringRef &lhs, QLatin1String rhs) noexcept { return rhs == lhs; }
inline bool operator!=(const QStringRef &lhs, QLatin1String rhs) noexcept { return rhs != lhs; }
inline bool operator< (const QStringRef &lhs, QLatin1String rhs) noexcept { return rhs >  lhs; }
inline bool operator> (const QStringRef &lhs, QLatin1String rhs) noexcept { return rhs <  lhs; }
inline bool operator<=(const QStringRef &lhs, QLatin1String rhs) noexcept { return rhs >= lhs; }
inline bool operator>=(const QStringRef &lhs, QLatin1String rhs) noexcept { return rhs <= lhs; }


inline bool operator==(QChar lhs, const QString &rhs) noexcept
{ return rhs.size() == 1 && lhs == rhs.front(); }
inline bool operator< (QChar lhs, const QString &rhs) noexcept
{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) <  0; }
inline bool operator> (QChar lhs, const QString &rhs) noexcept
{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) >  0; }

inline bool operator!=(QChar lhs, const QString &rhs) noexcept { return !(lhs == rhs); }
inline bool operator<=(QChar lhs, const QString &rhs) noexcept { return !(lhs >  rhs); }
inline bool operator>=(QChar lhs, const QString &rhs) noexcept { return !(lhs <  rhs); }

inline bool operator==(const QString &lhs, QChar rhs) noexcept { return   rhs == lhs; }
inline bool operator!=(const QString &lhs, QChar rhs) noexcept { return !(rhs == lhs); }
inline bool operator< (const QString &lhs, QChar rhs) noexcept { return   rhs >  lhs; }
inline bool operator> (const QString &lhs, QChar rhs) noexcept { return   rhs <  lhs; }
inline bool operator<=(const QString &lhs, QChar rhs) noexcept { return !(rhs <  lhs); }
inline bool operator>=(const QString &lhs, QChar rhs) noexcept { return !(rhs >  lhs); }


inline bool operator==(QChar lhs, const QStringRef &rhs) noexcept
{ return rhs.size() == 1 && lhs == rhs.front(); }
inline bool operator< (QChar lhs, const QStringRef &rhs) noexcept
{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) <  0; }
inline bool operator> (QChar lhs, const QStringRef &rhs) noexcept
{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) >  0; }

inline bool operator!=(QChar lhs, const QStringRef &rhs) noexcept { return !(lhs == rhs); }
inline bool operator<=(QChar lhs, const QStringRef &rhs) noexcept { return !(lhs >  rhs); }
inline bool operator>=(QChar lhs, const QStringRef &rhs) noexcept { return !(lhs <  rhs); }

inline bool operator==(const QStringRef &lhs, QChar rhs) noexcept { return   rhs == lhs; }
inline bool operator!=(const QStringRef &lhs, QChar rhs) noexcept { return !(rhs == lhs); }
inline bool operator< (const QStringRef &lhs, QChar rhs) noexcept { return   rhs >  lhs; }
inline bool operator> (const QStringRef &lhs, QChar rhs) noexcept { return   rhs <  lhs; }
inline bool operator<=(const QStringRef &lhs, QChar rhs) noexcept { return !(rhs <  lhs); }
inline bool operator>=(const QStringRef &lhs, QChar rhs) noexcept { return !(rhs >  lhs); }


inline bool operator==(QChar lhs, QLatin1String rhs) noexcept
{ return rhs.size() == 1 && lhs == rhs.front(); }
inline bool operator< (QChar lhs, QLatin1String rhs) noexcept
{ return QString::compare_helper(&lhs, 1, rhs) <  0; }
inline bool operator> (QChar lhs, QLatin1String rhs) noexcept
{ return QString::compare_helper(&lhs, 1, rhs) >  0; }

inline bool operator!=(QChar lhs, QLatin1String rhs) noexcept { return !(lhs == rhs); }
inline bool operator<=(QChar lhs, QLatin1String rhs) noexcept { return !(lhs >  rhs); }
inline bool operator>=(QChar lhs, QLatin1String rhs) noexcept { return !(lhs <  rhs); }

inline bool operator==(QLatin1String lhs, QChar rhs) noexcept { return   rhs == lhs; }
inline bool operator!=(QLatin1String lhs, QChar rhs) noexcept { return !(rhs == lhs); }
inline bool operator< (QLatin1String lhs, QChar rhs) noexcept { return   rhs >  lhs; }
inline bool operator> (QLatin1String lhs, QChar rhs) noexcept { return   rhs <  lhs; }
inline bool operator<=(QLatin1String lhs, QChar rhs) noexcept { return !(rhs <  lhs); }
inline bool operator>=(QLatin1String lhs, QChar rhs) noexcept { return !(rhs >  lhs); }


inline bool operator==(QStringView lhs, QStringView rhs) noexcept { return lhs.size() == rhs.size() && QtPrivate::compareStrings(lhs, rhs) == 0; }
inline bool operator!=(QStringView lhs, QStringView rhs) noexcept { return !(lhs == rhs); }
inline bool operator< (QStringView lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) <  0; }
inline bool operator<=(QStringView lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) <= 0; }
inline bool operator> (QStringView lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) >  0; }
inline bool operator>=(QStringView lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) >= 0; }


inline bool operator==(QStringView lhs, QChar rhs) noexcept { return lhs == QStringView(&rhs, 1); }
inline bool operator!=(QStringView lhs, QChar rhs) noexcept { return lhs != QStringView(&rhs, 1); }
inline bool operator< (QStringView lhs, QChar rhs) noexcept { return lhs <  QStringView(&rhs, 1); }
inline bool operator<=(QStringView lhs, QChar rhs) noexcept { return lhs <= QStringView(&rhs, 1); }
inline bool operator> (QStringView lhs, QChar rhs) noexcept { return lhs >  QStringView(&rhs, 1); }
inline bool operator>=(QStringView lhs, QChar rhs) noexcept { return lhs >= QStringView(&rhs, 1); }

inline bool operator==(QChar lhs, QStringView rhs) noexcept { return QStringView(&lhs, 1) == rhs; }
inline bool operator!=(QChar lhs, QStringView rhs) noexcept { return QStringView(&lhs, 1) != rhs; }
inline bool operator< (QChar lhs, QStringView rhs) noexcept { return QStringView(&lhs, 1) <  rhs; }
inline bool operator<=(QChar lhs, QStringView rhs) noexcept { return QStringView(&lhs, 1) <= rhs; }
inline bool operator> (QChar lhs, QStringView rhs) noexcept { return QStringView(&lhs, 1) >  rhs; }
inline bool operator>=(QChar lhs, QStringView rhs) noexcept { return QStringView(&lhs, 1) >= rhs; }


inline bool operator==(QStringView lhs, QLatin1String rhs) noexcept { return lhs.size() == rhs.size() && QtPrivate::compareStrings(lhs, rhs) == 0; }
inline bool operator!=(QStringView lhs, QLatin1String rhs) noexcept { return !(lhs == rhs); }
inline bool operator< (QStringView lhs, QLatin1String rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) <  0; }
inline bool operator<=(QStringView lhs, QLatin1String rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) <= 0; }
inline bool operator> (QStringView lhs, QLatin1String rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) >  0; }
inline bool operator>=(QStringView lhs, QLatin1String rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) >= 0; }

inline bool operator==(QLatin1String lhs, QStringView rhs) noexcept { return lhs.size() == rhs.size() && QtPrivate::compareStrings(lhs, rhs) == 0; }
inline bool operator!=(QLatin1String lhs, QStringView rhs) noexcept { return !(lhs == rhs); }
inline bool operator< (QLatin1String lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) <  0; }
inline bool operator<=(QLatin1String lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) <= 0; }
inline bool operator> (QLatin1String lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) >  0; }
inline bool operator>=(QLatin1String lhs, QStringView rhs) noexcept { return QtPrivate::compareStrings(lhs, rhs) >= 0; }



inline  bool operator==(const QStringRef &lhs, const QByteArray &rhs) { return lhs.compare(rhs) == 0; }
inline  bool operator!=(const QStringRef &lhs, const QByteArray &rhs) { return lhs.compare(rhs) != 0; }
inline  bool operator< (const QStringRef &lhs, const QByteArray &rhs) { return lhs.compare(rhs) <  0; }
inline  bool operator> (const QStringRef &lhs, const QByteArray &rhs) { return lhs.compare(rhs) >  0; }
inline  bool operator<=(const QStringRef &lhs, const QByteArray &rhs) { return lhs.compare(rhs) <= 0; }
inline  bool operator>=(const QStringRef &lhs, const QByteArray &rhs) { return lhs.compare(rhs) >= 0; }

inline  bool operator==(const QByteArray &lhs, const QStringRef &rhs) { return rhs.compare(lhs) == 0; }
inline  bool operator!=(const QByteArray &lhs, const QStringRef &rhs) { return rhs.compare(lhs) != 0; }
inline  bool operator< (const QByteArray &lhs, const QStringRef &rhs) { return rhs.compare(lhs) >  0; }
inline  bool operator> (const QByteArray &lhs, const QStringRef &rhs) { return rhs.compare(lhs) <  0; }
inline  bool operator<=(const QByteArray &lhs, const QStringRef &rhs) { return rhs.compare(lhs) >= 0; }
inline  bool operator>=(const QByteArray &lhs, const QStringRef &rhs) { return rhs.compare(lhs) <= 0; }


inline  bool QStringRef::operator==(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) == 0; }
inline  bool QStringRef::operator!=(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) != 0; }
inline  bool QStringRef::operator<(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) < 0; }
inline  bool QStringRef::operator<=(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) <= 0; }
inline  bool QStringRef::operator>(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) > 0; }
inline  bool QStringRef::operator>=(const char *s) const
{ return QString::compare_helper(constData(), size(), s, -1) >= 0; }

inline  bool operator==(const char *s1, const QStringRef &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) == 0; }
inline  bool operator!=(const char *s1, const QStringRef &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) != 0; }
inline  bool operator<(const char *s1, const QStringRef &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) > 0; }
inline  bool operator<=(const char *s1, const QStringRef &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) >= 0; }
inline  bool operator>(const char *s1, const QStringRef &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) < 0; }
inline  bool operator>=(const char *s1, const QStringRef &s2)
{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) <= 0; }
#line 2021 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

inline int QString::localeAwareCompare(const QStringRef &s) const
{ return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2)
{ return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
inline int QStringRef::localeAwareCompare(const QString &s) const
{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
inline int QStringRef::localeAwareCompare(const QStringRef &s) const
{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
inline int QStringRef::localeAwareCompare(QStringView s) const
{ return QString::localeAwareCompare_helper(constData(), length(), s.data(), int(s.size())); }
inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2)
{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2)
{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
inline int QStringRef::localeAwareCompare(QStringView s1, QStringView s2)
{ return QString::localeAwareCompare_helper(s1.data(), int(s1.size()), s2.data(), int(s2.size())); }


inline bool QStringRef::contains(const QString &s, Qt::CaseSensitivity cs) const
{ return indexOf(s, 0, cs) != -1; }
inline bool QStringRef::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
{ return indexOf(s, 0, cs) != -1; }
#line 2045 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
inline bool QStringRef::contains(QLatin1String s, Qt::CaseSensitivity cs) const
{ return indexOf(s, 0, cs) != -1; }
inline bool QStringRef::contains(QChar c, Qt::CaseSensitivity cs) const
{ return indexOf(c, 0, cs) != -1; }
inline bool QStringRef::contains(QStringView s, Qt::CaseSensitivity cs) const noexcept
{ return indexOf(s, 0, cs) != -1; }

inline QString &QString::insert(int i, const QStringRef &s)
{ return insert(i, s.constData(), s.length()); }
















#line 2071 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

namespace Qt {




#line 2078 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
}

namespace QtPrivate {

inline const QString &asString(const QString &s)    { return s; }
inline QString &&asString(QString &&s)              { return std::move(s); }
}





namespace QtPrivate {

struct ArgBase {
    enum Tag : uchar { L1, U8, U16 } tag;
};

struct QStringViewArg : ArgBase {
    QStringView string;
    QStringViewArg() = default;
    constexpr explicit QStringViewArg(QStringView v) noexcept : ArgBase{U16}, string{v} {}
};

struct QLatin1StringArg : ArgBase {
    QLatin1String string;
    QLatin1StringArg() = default;
    constexpr explicit QLatin1StringArg(QLatin1String v) noexcept : ArgBase{L1}, string{v} {}
};

[[nodiscard]] __declspec(dllimport) QString argToQString(QStringView pattern, size_t n, const ArgBase **args);
[[nodiscard]] __declspec(dllimport) QString argToQString(QLatin1String pattern, size_t n, const ArgBase **args);

template <typename StringView, typename...Args>
[[nodiscard]] __forceinline QString argToQStringDispatch(StringView pattern, const Args &...args)
{
    const ArgBase *argBases[] = {&args...,  nullptr};
    return QtPrivate::argToQString(pattern, sizeof...(Args), argBases);
}

                 inline QStringViewArg   qStringLikeToArg(const QString &s) noexcept { return QStringViewArg{qToStringViewIgnoringNull(s)}; }
constexpr inline QStringViewArg   qStringLikeToArg(QStringView s) noexcept { return QStringViewArg{s}; }
                 inline QStringViewArg   qStringLikeToArg(const QChar &c) noexcept { return QStringViewArg{QStringView{&c, 1}}; }
constexpr inline QLatin1StringArg qStringLikeToArg(QLatin1String s) noexcept { return QLatin1StringArg{s}; }

} 

template <typename...Args>
__forceinline
QString QStringView::arg(Args &&...args) const
{
    return QtPrivate::argToQStringDispatch(*this, QtPrivate::qStringLikeToArg(args)...);
}

template <typename...Args>
__forceinline
QString QLatin1String::arg(Args &&...args) const
{
    return QtPrivate::argToQStringDispatch(*this, QtPrivate::qStringLikeToArg(args)...);
}

inline qsizetype QStringView::count(QChar c, Qt::CaseSensitivity cs) const noexcept
{ return toString().count(c, cs); }
inline qsizetype QStringView::count(QStringView s, Qt::CaseSensitivity cs) const noexcept
{ return toString().count(s.toString(), cs); }

inline short QStringView::toShort(bool *ok, int base) const
{ return toString().toShort(ok, base); }
inline ushort QStringView::toUShort(bool *ok, int base) const
{ return toString().toUShort(ok, base); }
inline int QStringView::toInt(bool *ok, int base) const
{ return toString().toInt(ok, base); }
inline uint QStringView::toUInt(bool *ok, int base) const
{ return toString().toUInt(ok, base); }
inline long QStringView::toLong(bool *ok, int base) const
{ return toString().toLong(ok, base); }
inline ulong QStringView::toULong(bool *ok, int base) const
{ return toString().toULong(ok, base); }
inline qlonglong QStringView::toLongLong(bool *ok, int base) const
{ return toString().toLongLong(ok, base); }
inline qulonglong QStringView::toULongLong(bool *ok, int base) const
{ return toString().toULongLong(ok, base); }
inline float QStringView::toFloat(bool *ok) const
{ return toString().toFloat(ok); }
inline double QStringView::toDouble(bool *ok) const
{ return toString().toDouble(ok); }




#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"















































#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"



























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"







struct __declspec(dllimport) QAbstractConcatenable
{
protected:
    static void convertFromAscii(const char *a, int len, QChar *&out) noexcept;
    static inline void convertFromAscii(char a, QChar *&out) noexcept
    {
        *out++ = QLatin1Char(a);
    }
    static void appendLatin1To(const char *a, int len, QChar *out) noexcept;
};

template <typename T> struct QConcatenable {};

namespace QtStringBuilder {
    template <typename A, typename B> struct ConvertToTypeHelper
    { typedef A ConvertTo; };
    template <typename T> struct ConvertToTypeHelper<T, QString>
    { typedef QString ConvertTo; };
}

template<typename Builder, typename T>
struct QStringBuilderCommon
{
    T toUpper() const { return resolved().toUpper(); }
    T toLower() const { return resolved().toLower(); }

protected:
    T resolved() const { return *static_cast<const Builder*>(this); }
};

template<typename Builder, typename T>
struct QStringBuilderBase : public QStringBuilderCommon<Builder, T>
{
};

template<typename Builder>
struct QStringBuilderBase<Builder, QString> : public QStringBuilderCommon<Builder, QString>
{
    QByteArray toLatin1() const { return this->resolved().toLatin1(); }
    QByteArray toUtf8() const { return this->resolved().toUtf8(); }
    QByteArray toLocal8Bit() const { return this->resolved().toLocal8Bit(); }
};

template <typename A, typename B>
class QStringBuilder : public QStringBuilderBase<QStringBuilder<A, B>, typename QtStringBuilder::ConvertToTypeHelper<typename QConcatenable<A>::ConvertTo, typename QConcatenable<B>::ConvertTo>::ConvertTo>
{
public:
    QStringBuilder(const A &a_, const B &b_) : a(a_), b(b_) {}
private:
    friend class QByteArray;
    friend class QString;
    template <typename T> T convertTo() const
    {
        const uint len = QConcatenable< QStringBuilder<A, B> >::size(*this);
        T s(len, Qt::Uninitialized);

        
        
        typename T::iterator d = const_cast<typename T::iterator>(s.constData());
        typename T::const_iterator const start = d;
        QConcatenable< QStringBuilder<A, B> >::appendTo(*this, d);

        if (!QConcatenable< QStringBuilder<A, B> >::ExactSize && int(len) != d - start) {
            
            
            s.resize(d - start);
        }
        return s;
    }

    typedef QConcatenable<QStringBuilder<A, B> > Concatenable;
public:
    typedef typename Concatenable::ConvertTo ConvertTo;
    operator ConvertTo() const { return convertTo<ConvertTo>(); }

    int size() const { return Concatenable::size(*this); }

    const A &a;
    const B &b;
};

template <>
class QStringBuilder <QString, QString> : public QStringBuilderBase<QStringBuilder<QString, QString>, QString>
{
    public:
        QStringBuilder(const QString &a_, const QString &b_) : a(a_), b(b_) {}
        QStringBuilder(const QStringBuilder &other) : a(other.a), b(other.b) {}

        operator QString() const
        { QString r(a); r += b; return r; }

        const QString &a;
        const QString &b;

    private:
        QStringBuilder &operator=(const QStringBuilder &) = delete;
};

template <>
class QStringBuilder <QByteArray, QByteArray> : public QStringBuilderBase<QStringBuilder<QByteArray, QByteArray>, QByteArray>
{
    public:
        QStringBuilder(const QByteArray &a_, const QByteArray &b_) : a(a_), b(b_) {}
        QStringBuilder(const QStringBuilder &other) : a(other.a), b(other.b) {}

        operator QByteArray() const
        { QByteArray r(a); r += b; return r; }

        const QByteArray &a;
        const QByteArray &b;

    private:
        QStringBuilder &operator=(const QStringBuilder &) = delete;
};


template <> struct QConcatenable<char> : private QAbstractConcatenable
{
    typedef char type;
    typedef QByteArray ConvertTo;
    enum { ExactSize = true };
    static int size(const char) { return 1; }

    static inline  void appendTo(const char c, QChar *&out)
    {
        QAbstractConcatenable::convertFromAscii(c, out);
    }
#line 186 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"
    static inline void appendTo(const char c, char *&out)
    { *out++ = c; }
};


template <> struct QConcatenable<char16_t> : private QAbstractConcatenable
{
    typedef char16_t type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static constexpr int size(char16_t) { return 1; }
    static inline void appendTo(char16_t c, QChar *&out)
    { *out++ = c; }
};
#line 201 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"

template <> struct QConcatenable<QLatin1Char>
{
    typedef QLatin1Char type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(const QLatin1Char) { return 1; }
    static inline void appendTo(const QLatin1Char c, QChar *&out)
    { *out++ = c; }
    static inline void appendTo(const QLatin1Char c, char *&out)
    { *out++ = c.toLatin1(); }
};

template <> struct QConcatenable<QChar> : private QAbstractConcatenable
{
    typedef QChar type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(const QChar) { return 1; }
    static inline void appendTo(const QChar c, QChar *&out)
    { *out++ = c; }
};

template <> struct QConcatenable<QChar::SpecialCharacter> : private QAbstractConcatenable
{
    typedef QChar::SpecialCharacter type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(const QChar::SpecialCharacter) { return 1; }
    static inline void appendTo(const QChar::SpecialCharacter c, QChar *&out)
    { *out++ = c; }
};

template <> struct QConcatenable<QCharRef> : private QAbstractConcatenable
{
    typedef QCharRef type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(QCharRef) { return 1; }
    static inline void appendTo(QCharRef c, QChar *&out)
    { *out++ = QChar(c); }
};

template <> struct QConcatenable<QLatin1String> : private QAbstractConcatenable
{
    typedef QLatin1String type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(const QLatin1String a) { return a.size(); }
    static inline void appendTo(const QLatin1String a, QChar *&out)
    {
        appendLatin1To(a.latin1(), a.size(), out);
        out += a.size();
    }
    static inline void appendTo(const QLatin1String a, char *&out)
    {
        if (const char *data = a.data()) {
            memcpy(out, data, a.size());
            out += a.size();
        }
    }
};

template <> struct QConcatenable<QString> : private QAbstractConcatenable
{
    typedef QString type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(const QString &a) { return a.size(); }
    static inline void appendTo(const QString &a, QChar *&out)
    {
        const int n = a.size();
        memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
        out += n;
    }
};

template <> struct QConcatenable<QStringRef> : private QAbstractConcatenable
{
    typedef QStringRef type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(const QStringRef &a) { return a.size(); }
    static inline void appendTo(const QStringRef &a, QChar *&out)
    {
        const int n = a.size();
        memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
        out += n;
    }
};

template <> struct QConcatenable<QStringView> : private QAbstractConcatenable
{
    typedef QStringView type;
    typedef QString ConvertTo;
    enum { ExactSize = true };
    static int size(QStringView a) { return a.length(); }
    static inline void appendTo(QStringView a, QChar *&out)
    {
        const auto n = a.size();
        memcpy(out, a.data(), sizeof(QChar) * n);
        out += n;
    }
};

template <int N> struct QConcatenable<const char[N]> : private QAbstractConcatenable
{
    typedef const char type[N];
    typedef QByteArray ConvertTo;
    enum { ExactSize = false };
    static int size(const char[N]) { return N - 1; }

    static inline void  appendTo(const char a[N], QChar *&out)
    {
        QAbstractConcatenable::convertFromAscii(a, N - 1, out);
    }
#line 318 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"
    static inline void appendTo(const char a[N], char *&out)
    {
        while (*a)
            *out++ = *a++;
    }
};

template <int N> struct QConcatenable<char[N]> : QConcatenable<const char[N]>
{
    typedef char type[N];
};

template <> struct QConcatenable<const char *> : private QAbstractConcatenable
{
    typedef const char *type;
    typedef QByteArray ConvertTo;
    enum { ExactSize = false };
    static int size(const char *a) { return qstrlen(a); }

    static inline void  appendTo(const char *a, QChar *&out)
    { QAbstractConcatenable::convertFromAscii(a, -1, out); }
#line 340 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"
    static inline void appendTo(const char *a, char *&out)
    {
        if (!a)
            return;
        while (*a)
            *out++ = *a++;
    }
};

template <> struct QConcatenable<char *> : QConcatenable<const char*>
{
    typedef char *type;
};


template <int N> struct QConcatenable<const char16_t[N]> : private QAbstractConcatenable
{
    using type = const char16_t[N];
    using ConvertTo = QString;
    enum { ExactSize = true };
    static int size(const char16_t[N]) { return N - 1; }
    static void appendTo(const char16_t a[N], QChar *&out)
    {
        memcpy(out, a, (N - 1) * sizeof(char16_t));
        out += N - 1;
    }
};

template <int N> struct QConcatenable<char16_t[N]> : QConcatenable<const char16_t[N]>
{
    using type = char16_t[N];
};

template <> struct QConcatenable<const char16_t *> : private QAbstractConcatenable
{
    using type = const char16_t *;
    using ConvertTo = QString;
    enum { ExactSize = true };
    static int size(const char16_t *a) { return QStringView(a).length(); }
    static inline void  appendTo(const char16_t *a, QChar *&out)
    {
        if (!a)
            return;
        while (*a)
            *out++ = *a++;
    }
};

template <> struct QConcatenable<char16_t *> : QConcatenable<const char16_t*>
{
    typedef char16_t *type;
};
#line 393 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"

template <> struct QConcatenable<QByteArray> : private QAbstractConcatenable
{
    typedef QByteArray type;
    typedef QByteArray ConvertTo;
    enum { ExactSize = false };
    static int size(const QByteArray &ba) { return ba.size(); }

    static inline  void appendTo(const QByteArray &ba, QChar *&out)
    {
        QAbstractConcatenable::convertFromAscii(ba.constData(), ba.size(), out);
    }
#line 406 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"
    static inline void appendTo(const QByteArray &ba, char *&out)
    {
        const char *a = ba.constData();
        const char * const end = ba.end();
        while (a != end)
            *out++ = *a++;
    }
};


template <typename A, typename B>
struct QConcatenable< QStringBuilder<A, B> >
{
    typedef QStringBuilder<A, B> type;
    typedef typename QtStringBuilder::ConvertToTypeHelper<typename QConcatenable<A>::ConvertTo, typename QConcatenable<B>::ConvertTo>::ConvertTo ConvertTo;
    enum { ExactSize = QConcatenable<A>::ExactSize && QConcatenable<B>::ExactSize };
    static int size(const type &p)
    {
        return QConcatenable<A>::size(p.a) + QConcatenable<B>::size(p.b);
    }
    template<typename T> static inline void appendTo(const type &p, T *&out)
    {
        QConcatenable<A>::appendTo(p.a, out);
        QConcatenable<B>::appendTo(p.b, out);
    }
};

template <typename A, typename B>
QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
operator%(const A &a, const B &b)
{
   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>(a, b);
}




template <typename A, typename B>
QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
operator+(const A &a, const B &b)
{
   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>(a, b);
}
#line 450 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"

namespace QtStringBuilder {
template <typename A, typename B>
QByteArray &appendToByteArray(QByteArray &a, const QStringBuilder<A, B> &b, char)
{
    
    int len = a.size() + QConcatenable< QStringBuilder<A, B> >::size(b);
    a.reserve(len);
    char *it = a.data() + a.size();
    QConcatenable< QStringBuilder<A, B> >::appendTo(b, it);
    a.resize(len); 
    return a;
}








}

template <typename A, typename B>
QByteArray &operator+=(QByteArray &a, const QStringBuilder<A, B> &b)
{
    return QtStringBuilder::appendToByteArray(a, b,
                                              typename QConcatenable< QStringBuilder<A, B> >::ConvertTo::value_type());
}

template <typename A, typename B>
QString &operator+=(QString &a, const QStringBuilder<A, B> &b)
{
    int len = a.size() + QConcatenable< QStringBuilder<A, B> >::size(b);
    a.reserve(len);
    QChar *it = a.data() + a.size();
    QConcatenable< QStringBuilder<A, B> >::appendTo(b, it);
    a.resize(int(it - a.constData())); 
    return a;
}




#line 495 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringbuilder.h"
#pragma external_header(pop)
#line 2169 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
#line 2170 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"

#line 2172 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstring.h"
#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"


#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"












































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpair.h"















































template <class T1, class T2>
struct QPair
{
    typedef T1 first_type;
    typedef T2 second_type;

    constexpr QPair()
        noexcept((std::is_nothrow_default_constructible<T1>::value &&
                              std::is_nothrow_default_constructible<T2>::value))
        : first(), second() {}
    constexpr QPair(const T1 &t1, const T2 &t2)
        noexcept((std::is_nothrow_copy_constructible<T1>::value &&
                              std::is_nothrow_copy_constructible<T2>::value))
        : first(t1), second(t2) {}
    

    template <typename TT1, typename TT2>
    constexpr QPair(const QPair<TT1, TT2> &p)
        noexcept((std::is_nothrow_constructible<T1, TT1&>::value &&
                              std::is_nothrow_constructible<T2, TT2&>::value))
        : first(p.first), second(p.second) {}
    template <typename TT1, typename TT2>
    constexpr QPair &operator=(const QPair<TT1, TT2> &p)
        noexcept((std::is_nothrow_assignable<T1, TT1&>::value &&
                              std::is_nothrow_assignable<T2, TT2&>::value))
    { first = p.first; second = p.second; return *this; }
    template <typename TT1, typename TT2>
    constexpr QPair(QPair<TT1, TT2> &&p)
        noexcept((std::is_nothrow_constructible<T1, TT1>::value &&
                              std::is_nothrow_constructible<T2, TT2>::value))
        
        : first(static_cast<TT1 &&>(p.first)), second(static_cast<TT2 &&>(p.second)) {}
    template <typename TT1, typename TT2>
    constexpr QPair &operator=(QPair<TT1, TT2> &&p)
        noexcept((std::is_nothrow_assignable<T1, TT1>::value &&
                              std::is_nothrow_assignable<T2, TT2>::value))
    { first = std::move(p.first); second = std::move(p.second); return *this; }

    constexpr void swap(QPair &other)
        noexcept(noexcept(qSwap(other.first, other.first)) && noexcept(qSwap(other.second, other.second)))
    {
        
        qSwap(first, other.first);
        qSwap(second, other.second);
    }

    T1 first;
    T2 second;
};


template<class T1, class T2>
QPair(T1, T2) -> QPair<T1, T2>;
#line 102 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpair.h"

template <typename T1, typename T2>
void swap(QPair<T1, T2> &lhs, QPair<T1, T2> &rhs) noexcept(noexcept(lhs.swap(rhs)))
{ lhs.swap(rhs); }



template<class T1, class T2>
class QTypeInfo<QPair<T1, T2> > : public QTypeInfoMerger<QPair<T1, T2>, T1, T2> {}; 

template <class T1, class T2>
constexpr inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
    noexcept(noexcept(p1.first == p2.first && p1.second == p2.second))
{ return p1.first == p2.first && p1.second == p2.second; }

template <class T1, class T2>
constexpr inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
    noexcept(noexcept(!(p1 == p2)))
{ return !(p1 == p2); }

template <class T1, class T2>
constexpr inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
    noexcept(noexcept(p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second)))
{
    return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
}

template <class T1, class T2>
constexpr inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
    noexcept(noexcept(p2 < p1))
{
    return p2 < p1;
}

template <class T1, class T2>
constexpr inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
    noexcept(noexcept(!(p2 < p1)))
{
    return !(p2 < p1);
}

template <class T1, class T2>
constexpr inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
    noexcept(noexcept(!(p1 < p2)))
{
    return !(p1 < p2);
}

template <class T1, class T2>
constexpr inline QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
    noexcept(noexcept(QPair<T1, T2>(x, y)))
{
    return QPair<T1, T2>(x, y);
}



#line 160 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpair.h"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"





#pragma once







#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"





#pragma once













#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"

#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"



#line 28 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.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 {
extern "C" {
extern int __isa_available;
}

inline constexpr int _Stl_isa_available_sse42 = 2; 
inline constexpr int _Stl_isa_available_avx2  = 5; 

template <class _UInt>
inline constexpr int _Unsigned_integer_digits = sizeof(_UInt) * 8;




template <class _Ty>
[[nodiscard]] constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
    _Ty _Yx = 0;

    unsigned int _Nx = _Unsigned_integer_digits<_Ty>;
    unsigned int _Cx = _Unsigned_integer_digits<_Ty> / 2;
    do {
        _Yx = static_cast<_Ty>(_Val >> _Cx);
        if (_Yx != 0) {
            _Nx -= _Cx;
            _Val = _Yx;
        }
        _Cx >>= 1;
    } while (_Cx != 0);
    return static_cast<int>(_Nx) - static_cast<int>(_Val);
}





#line 72 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"



template <class _Ty>
[[nodiscard]] int _Countl_zero_lzcnt(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;

    if constexpr (_Digits <= 16) {
        return static_cast<int>(__lzcnt16(_Val) - (16 - _Digits));
    } else if constexpr (_Digits == 32) {
        return static_cast<int>(__lzcnt(_Val));
    } else {









        return static_cast<int>(__lzcnt64(_Val));
#line 95 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
}

template <class _Ty>
[[nodiscard]] int _Countl_zero_bsr(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;

    unsigned long _Result;
    if constexpr (_Digits <= 32) {
        if (!_BitScanReverse(&_Result, _Val)) {
            return _Digits;
        }
    } else {











        if (!_BitScanReverse64(&_Result, _Val)) {
            return _Digits;
        }
#line 123 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
    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 >= _Stl_isa_available_avx2;
    if (_Definitely_have_lzcnt) {
        return _Countl_zero_lzcnt(_Val);
    } else {
        return _Countl_zero_bsr(_Val);
    }
#line 139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
}
#line 141 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"










































#line 184 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
#line 185 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"




template <class _Ty>
[[nodiscard]] constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
    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 = _Unsigned_integer_digits<_Ty>;







#line 208 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    
    _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 225 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"








#line 234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"

template <class _Ty>
[[nodiscard]] int _Countr_zero_tzcnt(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
    constexpr _Ty _Max    = static_cast<_Ty>(-1); 

    if constexpr (_Digits <= 32) {
        
        
        
        return static_cast<int>(_tzcnt_u32(static_cast<unsigned int>(~_Max | _Val)));
    } else {









        return static_cast<int>(_tzcnt_u64(_Val));
#line 257 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
}




template <class _Ty>
[[nodiscard]] int _Countr_zero_bsf(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
    constexpr _Ty _Max    = static_cast<_Ty>(-1); 

    unsigned long _Result;
    if constexpr (_Digits <= 32) {
        
        
        
        if (!_BitScanForward(&_Result, static_cast<unsigned int>(~_Max | _Val))) {
            return _Digits;
        }
    } else {













        if (!_BitScanForward64(&_Result, _Val)) {
            return _Digits;
        }
#line 294 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
    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 >= _Stl_isa_available_avx2;
    if (_Definitely_have_tzcnt) {
        return _Countr_zero_tzcnt(_Val);
    } else {
        return _Countr_zero_bsf(_Val);
    }
#line 310 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
}

#line 313 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"





#line 320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"


template <class _Ty>
[[nodiscard]] int _Unchecked_x86_x64_popcount(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
    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>(__popcnt64(_Val));
#line 335 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
}

template <class _Ty>
[[nodiscard]] int _Checked_x86_x64_popcount(const _Ty _Val) noexcept {

    const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
    if (!_Definitely_have_popcnt) {
        return _Popcount_fallback(_Val);
    }
#line 346 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    return _Unchecked_x86_x64_popcount(_Val);
}
#line 349 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"






#line 356 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"

template <class _Ty>
inline 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 367 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    {
        return _Checked_x86_x64_countr_zero(_Val);
    }
#line 371 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    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 >= _Stl_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 389 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
#line 391 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    
    return _Callback([](_Ty _Val) { return _Countr_zero_fallback(_Val); });
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int _Popcount(const _Ty _Val) noexcept {


    if (!::std:: is_constant_evaluated())
#line 401 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    {

        return _Checked_x86_x64_popcount(_Val);


#line 407 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
#line 409 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    return _Popcount_fallback(_Val);
}

template <class _Ty, class _Fn>
constexpr decltype(auto) _Select_popcount_impl(_Fn _Callback) {
    


    if (!::std:: is_constant_evaluated())
#line 419 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    {


        const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
        if (!_Definitely_have_popcnt) {
            return _Callback([](_Ty _Val) { return _Popcount_fallback(_Val); });
        }
#line 427 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
        return _Callback([](_Ty _Val) { return _Unchecked_x86_x64_popcount(_Val); });


#line 431 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    }
#line 433 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
    return _Callback([](_Ty _Val) { return _Popcount_fallback(_Val); });
}




}





#pragma warning(pop)
#pragma pack(pop)
#line 448 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
#line 449 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_bit_utils.hpp"
#pragma external_header(pop)
#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"



#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 40 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 73 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 84 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_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_ranges_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 128 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 144 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 194 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_ranges_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_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, _FwdIt _First1, _FwdIt _Last1, _Ty _Val, _BinOp _Reduce_op,
    _UnaryOp _Transform_op) noexcept; 
#line 246 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 269 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _FwdIt1 _First, _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, _FwdIt1 _First, _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, _FwdIt1 _First, _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, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
    _UnaryOp _Transform_op) noexcept; 
#line 475 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 493 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, _FwdIt1 _First, _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 521 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }
}











































#line 576 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"


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));
        auto _Nx_trailing_zeroes        = static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
        const auto _Common_factors_of_2 = (::std:: min)(_Mx_trailing_zeroes, _Nx_trailing_zeroes);
        _Mx_magnitude >>= _Mx_trailing_zeroes;
        for (;;) {
            _Nx_magnitude >>= _Nx_trailing_zeroes;
            if (_Mx_magnitude > _Nx_magnitude) {
                _Common_unsigned _Temp = _Mx_magnitude;
                _Mx_magnitude          = _Nx_magnitude;
                _Nx_magnitude          = _Temp;
            }

            _Nx_magnitude -= _Mx_magnitude;
            if (_Nx_magnitude == 0U) {
                return static_cast<_Common>(_Mx_magnitude << _Common_factors_of_2);
            }

            _Nx_trailing_zeroes = static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
        }
    });
}

 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 653 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"


template <class _Flt>
inline constexpr _Flt _Floating_max{};
template <>
inline constexpr float _Floating_max<float> = 3.402823466e+38F;
template <>
inline constexpr double _Floating_max<double> = 1.7976931348623158e+308;
template <>
inline constexpr long double _Floating_max<long double> = 1.7976931348623158e+308;

template <class _Flt>
inline constexpr _Flt _Floating_min{};
template <>
inline constexpr float _Floating_min<float> = 1.175494351e-38F;
template <>
inline constexpr double _Floating_min<double> = 2.2250738585072014e-308;
template <>
inline constexpr long double _Floating_min<long double> = 2.2250738585072014e-308;

 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 = _Floating_max<remove_cv_t<_Ty>> / 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 = _Floating_min<remove_cv_t<_Ty>> * 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 747 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"
}


#pragma warning(pop)
#pragma pack(pop)
#line 753 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"
#line 754 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\numeric"
#pragma external_header(pop)
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"





#pragma once






#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeinfo"





#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 : 4275) 

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"







#pragma once






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

#pragma pack(push, 8)

extern "C++" { 





#line 27 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"
    struct __type_info_node;
#line 29 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"




    extern __type_info_node __type_info_root_node;
#line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) 
extern "C++" { 
class type_info
{
public:

    type_info(const type_info&) = delete;
    type_info& operator=(const type_info&) = delete;

    [[nodiscard]] size_t hash_code() const noexcept
    {
        return __std_type_info_hash(&_Data);
    }

    [[nodiscard]]


#line 89 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"
    bool operator==(const type_info& _Other) const noexcept
    {





#line 97 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"

        return __std_type_info_compare(&_Data, &_Other._Data) == 0;
    }






#line 107 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"

    [[nodiscard]] bool before(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) < 0;
    }

    [[nodiscard]] const char* name() const noexcept
    {
        


        return __std_type_info_name(&_Data, &__type_info_root_node);
        #line 120 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"
    }

    [[nodiscard]] 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 216 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"
#pragma pack(pop)
#pragma warning(pop) 
#line 219 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vcruntime_typeinfo.h"
#pragma external_header(pop)
#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeinfo"

 extern "C++" class type_info; 

namespace std {


inline constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);

 using ::type_info;


 class bad_cast;
 class bad_typeid;





























#line 67 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeinfo"

[[noreturn]] inline void _Throw_bad_cast() {
    throw bad_cast{};
}

}



#pragma pack(pop)
#pragma warning(pop)
#line 79 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeinfo"
#line 80 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeinfo"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"





#pragma once












#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"



#line 25 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"



#line 29 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 77 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"
}

[[nodiscard]]   inline float copysign(  float _Number,   float _Sign) noexcept  {

    return __copysignf(_Number, _Sign);




#line 87 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 133 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 247 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 289 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 332 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"
}

[[nodiscard]]   inline long double copysign(  long double _Number,   long double _Sign) noexcept
 {

    return __copysign(static_cast<double>(_Number), static_cast<double>(_Sign));




#line 343 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 390 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 513 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 555 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"




























#line 640 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { return :: atan2(static_cast<double>(_Left), static_cast<double>(_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 { return :: hypot(static_cast<double>(_Left), static_cast<double>(_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 { return :: pow(static_cast<double>(_Left), static_cast<double>(_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 { return :: fmod(static_cast<double>(_Left), static_cast<double>(_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 { return :: remainder(static_cast<double>(_Left), static_cast<double>(_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 { return __copysign(static_cast<double>(_Left), static_cast<double>(_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 { return :: nextafter(static_cast<double>(_Left), static_cast<double>(_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 { return :: fdim(static_cast<double>(_Left), static_cast<double>(_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 { return :: fmax(static_cast<double>(_Left), static_cast<double>(_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 { return :: fmin(static_cast<double>(_Left), static_cast<double>(_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;

inline namespace _Binary_hypot {
     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) noexcept  {
    return __std_smf_assoc_laguerre(_Degree, _Order, _Value);
}

 [[nodiscard]] inline float assoc_laguerref(
    const unsigned int _Degree, const unsigned int _Order, const float _Value) noexcept  {
    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) noexcept  {
    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) noexcept  {
    return __std_smf_assoc_legendre(_Degree, _Order, _Value);
}

 [[nodiscard]] inline float assoc_legendref(
    const unsigned int _Degree, const unsigned int _Order, const float _Value) noexcept  {
    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) noexcept  {
    return __std_smf_assoc_legendre(_Degree, _Order, static_cast<double>(_Value));
}

 [[nodiscard]] inline double beta(const double _Arg1, const double _Arg2) noexcept  {
    return __std_smf_beta(_Arg1, _Arg2);
}

 [[nodiscard]] inline float betaf(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_betaf(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double betal(const long double _Arg1, const long double _Arg2) noexcept
 {
    return __std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

 [[nodiscard]] inline double comp_ellint_1(const double _Arg) noexcept  {
    return __std_smf_comp_ellint_1(_Arg);
}

 [[nodiscard]] inline float comp_ellint_1f(const float _Arg) noexcept  {
    return __std_smf_comp_ellint_1f(_Arg);
}

 [[nodiscard]] inline long double comp_ellint_1l(const long double _Arg) noexcept  {
    return __std_smf_comp_ellint_1(static_cast<double>(_Arg));
}

 [[nodiscard]] inline double comp_ellint_2(const double _Arg) noexcept  {
    return __std_smf_comp_ellint_2(_Arg);
}

 [[nodiscard]] inline float comp_ellint_2f(const float _Arg) noexcept  {
    return __std_smf_comp_ellint_2f(_Arg);
}

 [[nodiscard]] inline long double comp_ellint_2l(const long double _Arg) noexcept  {
    return __std_smf_comp_ellint_2(static_cast<double>(_Arg));
}

 [[nodiscard]] inline double comp_ellint_3(const double _Arg1, const double _Arg2) noexcept  {
    return __std_smf_comp_ellint_3(_Arg1, _Arg2);
}

 [[nodiscard]] inline float comp_ellint_3f(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_comp_ellint_3f(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) noexcept
 {
    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) noexcept  {
    return __std_smf_cyl_bessel_i(_Arg1, _Arg2);
}

 [[nodiscard]] inline float cyl_bessel_if(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_cyl_bessel_if(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) noexcept
 {
    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) noexcept  {
    return __std_smf_cyl_bessel_j(_Arg1, _Arg2);
}

 [[nodiscard]] inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_cyl_bessel_jf(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) noexcept
 {
    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) noexcept  {
    return __std_smf_cyl_bessel_k(_Arg1, _Arg2);
}

 [[nodiscard]] inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_cyl_bessel_kf(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) noexcept
 {
    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) noexcept  {
    return __std_smf_cyl_neumann(_Arg1, _Arg2);
}

 [[nodiscard]] inline float cyl_neumannf(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_cyl_neumannf(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) noexcept
 {
    return __std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

 [[nodiscard]] inline double ellint_1(const double _Arg1, const double _Arg2) noexcept  {
    return __std_smf_ellint_1(_Arg1, _Arg2);
}

 [[nodiscard]] inline float ellint_1f(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_ellint_1f(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double ellint_1l(const long double _Arg1, const long double _Arg2) noexcept
 {
    return __std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

 [[nodiscard]] inline double ellint_2(const double _Arg1, const double _Arg2) noexcept  {
    return __std_smf_ellint_2(_Arg1, _Arg2);
}

 [[nodiscard]] inline float ellint_2f(const float _Arg1, const float _Arg2) noexcept  {
    return __std_smf_ellint_2f(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double ellint_2l(const long double _Arg1, const long double _Arg2) noexcept
 {
    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) noexcept
 {
    return __std_smf_ellint_3(_Arg1, _Arg2, _Arg3);
}

 [[nodiscard]] inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) noexcept
 {
    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) noexcept  {
    return __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3));
}

 [[nodiscard]] inline double expint(const double _Arg) noexcept  {
    return __std_smf_expint(_Arg);
}

 [[nodiscard]] inline float expintf(const float _Arg) noexcept  {
    return __std_smf_expintf(_Arg);
}

 [[nodiscard]] inline long double expintl(const long double _Arg) noexcept  {
    return __std_smf_expint(static_cast<double>(_Arg));
}

 [[nodiscard]] inline double hermite(const unsigned int _Arg1, const double _Arg2) noexcept  {
    return __std_smf_hermite(_Arg1, _Arg2);
}

 [[nodiscard]] inline float hermitef(const unsigned int _Arg1, const float _Arg2) noexcept  {
    return __std_smf_hermitef(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) noexcept
 {
    return __std_smf_hermite(_Arg1, static_cast<double>(_Arg2));
}

 [[nodiscard]] inline double laguerre(const unsigned int _Arg1, const double _Arg2) noexcept
 {
    return __std_smf_laguerre(_Arg1, _Arg2);
}

 [[nodiscard]] inline float laguerref(const unsigned int _Arg1, const float _Arg2) noexcept  {
    return __std_smf_laguerref(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) noexcept
 {
    return __std_smf_laguerre(_Arg1, static_cast<double>(_Arg2));
}

 [[nodiscard]] inline double legendre(const unsigned int _Degree, const double _Value) noexcept
 {
    return __std_smf_legendre(_Degree, _Value);
}

 [[nodiscard]] inline float legendref(const unsigned int _Degree, const float _Value) noexcept
 {
    return __std_smf_legendref(_Degree, _Value);
}

 [[nodiscard]] inline long double legendrel(const unsigned int _Degree, const long double _Value) noexcept
 {
    return __std_smf_legendre(_Degree, static_cast<double>(_Value));
}

 [[nodiscard]] inline double riemann_zeta(const double _Arg) noexcept  {
    return __std_smf_riemann_zeta(_Arg);
}
 [[nodiscard]] inline float riemann_zetaf(const float _Arg) noexcept  {
    return __std_smf_riemann_zetaf(_Arg);
}

 [[nodiscard]] inline long double riemann_zetal(const long double _Arg) noexcept  {
    return __std_smf_riemann_zeta(static_cast<double>(_Arg));
}

 [[nodiscard]] inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) noexcept
 {
    return __std_smf_sph_bessel(_Arg1, _Arg2);
}

 [[nodiscard]] inline float sph_besself(const unsigned int _Arg1, const float _Arg2) noexcept
 {
    return __std_smf_sph_besself(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) noexcept
 {
    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) noexcept
 {
    return __std_smf_sph_legendre(_Arg1, _Arg2, _Theta);
}

 [[nodiscard]] inline float sph_legendref(
    const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) noexcept
 {
    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) noexcept  {
    return __std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Theta));
}

 [[nodiscard]] inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) noexcept
 {
    return __std_smf_sph_neumann(_Arg1, _Arg2);
}

 [[nodiscard]] inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) noexcept
 {
    return __std_smf_sph_neumannf(_Arg1, _Arg2);
}

 [[nodiscard]] inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) noexcept
 {
    return __std_smf_sph_neumann(_Arg1, static_cast<double>(_Arg2));
}





























































 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto assoc_laguerre( const unsigned int _Arg1, const unsigned int _Arg2, const _Ty _Arg3) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_assoc_laguerref(_Arg1, _Arg2, _Arg3); } else { return static_cast<_Common>(__std_smf_assoc_laguerre(_Arg1, _Arg2, static_cast<double>(_Arg3))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto assoc_legendre( const unsigned int _Arg1, const unsigned int _Arg2, const _Ty _Arg3) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_assoc_legendref(_Arg1, _Arg2, _Arg3); } else { return static_cast<_Common>(__std_smf_assoc_legendre(_Arg1, _Arg2, static_cast<double>(_Arg3))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto beta(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_betaf(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto comp_ellint_1(const _Ty _Arg) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_comp_ellint_1f(_Arg); } else { return static_cast<_Common>(__std_smf_comp_ellint_1(static_cast<double>(_Arg))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto comp_ellint_2(const _Ty _Arg) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_comp_ellint_2f(_Arg); } else { return static_cast<_Common>(__std_smf_comp_ellint_2(static_cast<double>(_Arg))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto comp_ellint_3(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_comp_ellint_3f(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_comp_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto cyl_bessel_i(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_cyl_bessel_if(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_cyl_bessel_i(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto cyl_bessel_j(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_cyl_bessel_jf(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_cyl_bessel_j(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto cyl_bessel_k(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_cyl_bessel_kf(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_cyl_bessel_k(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto cyl_neumann(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_cyl_neumannf(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto ellint_1(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_ellint_1f(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] auto ellint_2(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept { using _Common = _Common_float_type_t<_Ty1, _Ty2>; if constexpr (is_same_v<_Common, float>) { return __std_smf_ellint_2f(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_ellint_2(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); } }
 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 ellint_3(const _Ty1 _Arg1, const _Ty2 _Arg2, const _Ty3 _Arg3) noexcept { using _Common = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>; if constexpr (is_same_v<_Common, float>) { return __std_smf_ellint_3f(_Arg1, _Arg2, _Arg3); } else { return static_cast<_Common>( __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto expint(const _Ty _Arg) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_expintf(_Arg); } else { return static_cast<_Common>(__std_smf_expint(static_cast<double>(_Arg))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto hermite(const unsigned int _Arg1, const _Ty _Arg2) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_hermitef(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_hermite(_Arg1, static_cast<double>(_Arg2))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto laguerre(const unsigned int _Arg1, const _Ty _Arg2) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_laguerref(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_laguerre(_Arg1, static_cast<double>(_Arg2))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto legendre(const unsigned int _Arg1, const _Ty _Arg2) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_legendref(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_legendre(_Arg1, static_cast<double>(_Arg2))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto riemann_zeta(const _Ty _Arg) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_riemann_zetaf(_Arg); } else { return static_cast<_Common>(__std_smf_riemann_zeta(static_cast<double>(_Arg))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto sph_bessel(const unsigned int _Arg1, const _Ty _Arg2) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_sph_besself(_Arg1, _Arg2); } else { return static_cast<_Common>(__std_smf_sph_bessel(_Arg1, static_cast<double>(_Arg2))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto sph_legendre( const unsigned int _Arg1, const unsigned int _Arg2, const _Ty _Arg3) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_sph_legendref(_Arg1, _Arg2, _Arg3); } else { return static_cast<_Common>(__std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Arg3))); } }
 template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0> [[nodiscard]] auto sph_neumann(const unsigned int _Arg1, const _Ty _Arg2) noexcept { using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>; if constexpr (is_same_v<_Common, float>) { return __std_smf_sph_neumannf(_Arg1, _Arg2); } else { return static_cast<_Common>(__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 _Linear_for_lerp(const _Ty _ArgA, const _Ty _ArgB, const _Ty _ArgT) {
    if (::std:: is_constant_evaluated()) {
        auto _Smaller     = _ArgT;
        auto _Larger      = _ArgB - _ArgA;
        auto _Abs_smaller = _Float_abs(_Smaller);
        auto _Abs_larger  = _Float_abs(_Larger);
        if (_Abs_larger < _Abs_smaller) {
            ::std:: swap(_Smaller, _Larger);
            ::std:: swap(_Abs_smaller, _Abs_larger);
        }

        if (_Abs_smaller > 1) {
            
            
            
            return 2 * (_Ty{0.5} * _ArgA + _Smaller * (_Ty{0.5} * _Larger));
        } else {
            return _ArgA + _Smaller * _Larger;
        }
    }

    return ::std:: fma(_ArgT, _ArgB - _ArgA, _ArgA);
}

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 = _Linear_for_lerp(_ArgA, _ArgB, _ArgT);
        
        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);
}

 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]] constexpr auto lerp(const _Ty1 _ArgA, const _Ty2 _ArgB, const _Ty3 _ArgT) noexcept {
    using _Tgt = conditional_t<_Is_any_of_v<long double, _Ty1, _Ty2, _Ty3>, long double, double>;
    return _Common_lerp(static_cast<_Tgt>(_ArgA), static_cast<_Tgt>(_ArgB), static_cast<_Tgt>(_ArgT));
}
#line 1482 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"
}
#line 1484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"



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

#line 1491 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"
#line 1492 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cmath"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 147, 0, "%s", "cannot dereference value-initialized list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 147, 0); } while (false); } ; } while (false);
        do { if (this->_Ptr != _Mycont->_Myhead) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 148, 0, "%s", "cannot dereference end list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 148, 0); } while (false); } ; } while (false);
#line 150 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        return this->_Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _List_const_iterator& operator++() noexcept {

        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 161, 0, "%s", "cannot increment value-initialized list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 161, 0); } while (false); } ; } while (false);
        do { if (this->_Ptr != _Mycont->_Myhead) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 162, 0, "%s", "cannot increment end list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment end list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 162, 0); } while (false); } ; } while (false);
#line 164 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 179, 0, "%s", "cannot decrement value-initialized list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 179, 0); } while (false); } ; } while (false);
        do { if (_New_ptr != _Mycont->_Myhead) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 180, 0, "%s", "cannot decrement begin list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement begin list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 180, 0); } while (false); } ; } while (false);
#line 182 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 195, 0, "%s", "list iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 195, 0); } while (false); } ; } while (false);
#line 197 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        return this->_Ptr == _Right._Ptr;
    }





#line 206 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"


    friend void _Verify_range(const _List_const_iterator& _First, const _List_const_iterator& _Last) noexcept {
        do { if (_First._Getcont() == _Last._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 209, 0, "%s", "list iterators in range are from different containers")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list iterators in range are from different containers\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 209, 0); } while (false); } ; } while (false);
    }
#line 212 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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 = 
        _Returns_exactly<_Value_type>(); 

    _List_node()                             = default;
    _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 { 

        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
        const auto _Head          = _Myhead;
        while (*_Pnext) {
            _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
            const auto _Pnextptr          = static_cast<_List_const_iterator<_List_val>&>(**_Pnext)._Ptr;
            if (_Pnextptr == _Head || _Pnextptr != _Ptr) {
                
                _Pnext = _Pnextnext;
            } else { 
                (*_Pnext)->_Myproxy = nullptr;
                *_Pnext             = *_Pnextnext;
            }
        }


#line 375 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
    }

    void _Orphan_non_end() noexcept { 

        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
        const auto _Head          = _Myhead;
        while (*_Pnext) {
            _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
            if (static_cast<_List_const_iterator<_List_val>&>(**_Pnext)._Ptr == _Head) { 
                _Pnext = _Pnextnext;
            } else { 
                (*_Pnext)->_Myproxy = nullptr;
                *_Pnext             = *_Pnextnext;
            }
        }
#line 392 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
    }

    _Nodeptr _Unlinknode(_Nodeptr _Pnode) noexcept { 
        _Orphan_ptr2(_Pnode);
        _Pnode->_Prev->_Next = _Pnode->_Next;
        _Pnode->_Next->_Prev = _Pnode->_Prev;
        --_Mysize;
        return _Pnode;
    }


    void _Adopt_unique(_List_val& _Other, _Nodeptr _Pnode) noexcept {
        
        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &_Other._Myproxy->_Myfirstiter;
        const auto _Myproxy       = this->_Myproxy;
        while (*_Pnext) {
            auto& _Iter = static_cast<_List_const_iterator<_List_val>&>(**_Pnext);
            if (_Iter._Ptr == _Pnode) { 
                *_Pnext                = _Iter._Mynextiter;
                _Iter._Myproxy         = _Myproxy;
                _Iter._Mynextiter      = _Myproxy->_Myfirstiter;
                _Myproxy->_Myfirstiter = ::std:: addressof(_Iter);
            } else { 
                _Pnext = &_Iter._Mynextiter;
            }
        }
    }

    void _Adopt_all(_List_val& _Other) noexcept {
        
        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &_Other._Myproxy->_Myfirstiter;
        const auto _Myproxy       = this->_Myproxy;
        const auto _Otherhead     = _Other._Myhead;
        while (*_Pnext) {
            auto& _Iter = static_cast<_List_const_iterator<_List_val>&>(**_Pnext);
            if (_Iter._Ptr != _Otherhead) { 
                *_Pnext                = _Iter._Mynextiter;
                _Iter._Myproxy         = _Myproxy;
                _Iter._Mynextiter      = _Myproxy->_Myfirstiter;
                _Myproxy->_Myfirstiter = ::std:: addressof(_Iter);
            } else { 
                _Pnext = &_Iter._Mynextiter;
            }
        }
    }

    void _Adopt_range(_List_val& _Other, const _Nodeptr _First, const _Nodeptr _Last) noexcept {
        
        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &_Other._Myproxy->_Myfirstiter;
        const auto _Myproxy       = this->_Myproxy;
        _Nodeptr _Oldprev         = _First->_Prev;
        for (_Nodeptr _Ptr = _First; _Ptr != _Last; _Ptr = _Ptr->_Next) { 
            _Ptr->_Prev = nullptr;
        }

        while (*_Pnext) { 
            auto& _Iter = static_cast<_List_const_iterator<_List_val>&>(**_Pnext);
            if (_Iter._Ptr->_Prev) { 
                _Pnext = &_Iter._Mynextiter;
            } else { 
                *_Pnext                = _Iter._Mynextiter;
                _Iter._Myproxy         = _Myproxy;
                _Iter._Mynextiter      = _Myproxy->_Myfirstiter;
                _Myproxy->_Myfirstiter = ::std:: addressof(_Iter);
            }
        }

        for (_Nodeptr _Ptr = _First; _Ptr != _Last; _Ptr = _Ptr->_Next) { 
            _Ptr->_Prev = _Oldprev;
            _Oldprev    = _Ptr;
        }
    }
#line 468 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_Pred, _Mid->_Myval, _First->_Myval)) {
            
            _Newfirst = _Mid;
        } else {
            
            
            _Newfirst = _First;
            do {
                _First = _First->_Next;
                if (_First == _Mid) {
                    return _Newfirst;
                }
            } while (!_Debug_lt_pred(_Pred, _Mid->_Myval, _First->_Myval));
        }

        for (;;) { 
            auto _Run_start = _Mid;
            do { 
                _Mid = _Mid->_Next;
            } while (_Mid != _Last && _Debug_lt_pred(_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 (!_Debug_lt_pred(_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, _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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
                                    "because of [container.requirements].");

    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(__declspec(guard(overflow)) size_type _Count) {
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _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(__declspec(guard(overflow)) size_type _Count)
        : _Mypair(_Zero_then_variadic_args_t{}) { 
        _Construct_n(_Count);
    }

    explicit list(__declspec(guard(overflow)) size_type _Count, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Construct_n(_Count);
    }

private:
    void _Construct_n(__declspec(guard(overflow)) size_type _Count, const _Ty& _Val) {
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _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(__declspec(guard(overflow)) size_type _Count, const _Ty& _Val)
        : _Mypair(_Zero_then_variadic_args_t{}) { 
        _Construct_n(_Count, _Val);
    }

    list(__declspec(guard(overflow)) size_type _Count, const _Ty& _Val, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Construct_n(_Count, _Val);
    }

private:
    template <class _Iter, class _Sent>
    void _Construct_range_unchecked(_Iter _First, const _Sent _Last) {
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _List_node_insert_op2<_Alnode> _Appended(_Getal());
        _Appended._Append_range_unchecked(::std:: move(_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));
    }











#line 898 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

    list(list&& _Right) noexcept(false) : _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);
    }

    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       = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al);
                auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al);
                _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 { 
        using ::std:: swap;
        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;
        _My_data._Swap_proxy_and_iterators(_Right_data);
        swap(_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 990 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
    }

    template <class... _Valty>
    decltype(auto) emplace_back(_Valty&&... _Val) { 
        reference _Result = _Emplace(_Mypair._Myval2._Myhead, ::std:: forward<_Valty>(_Val)...)->_Myval;


        return _Result;


#line 1001 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
    }

    template <class... _Valty>
    iterator emplace(const const_iterator _Where, _Valty&&... _Val) { 

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1006, 0, "%s", "list emplace iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list emplace iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1006, 0); } while (false); } ; } while (false);
#line 1008 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();

        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _Delete_plain_internal(_Alproxy, _Mypair._Myval2._Myproxy);
#line 1051 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
    }

private:
    void _Reload_sentinel_and_proxy(const list& _Right) { 
        auto& _Al             = _Getal();
        auto&& _Alproxy       = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al);
        auto& _Right_al       = _Right._Getal();
        auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al);
        _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(__declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1207, 0, "%s", "front() called on empty list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1207, 0); } while (false); } ; } while (false);
#line 1209 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        return _Mypair._Myval2._Myhead->_Next->_Myval;
    }

    [[nodiscard]] const_reference front() const noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1215, 0, "%s", "front() called on empty list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1215, 0); } while (false); } ; } while (false);
#line 1217 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        return _Mypair._Myval2._Myhead->_Next->_Myval;
    }

    [[nodiscard]] reference back() noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1223, 0, "%s", "back() called on empty list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1223, 0); } while (false); } ; } while (false);
#line 1225 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        return _Mypair._Myval2._Myhead->_Prev->_Myval;
    }

    [[nodiscard]] const_reference back() const noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1231, 0, "%s", "back() called on empty list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1231, 0); } while (false); } ; } while (false);
#line 1233 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        return _Mypair._Myval2._Myhead->_Prev->_Myval;
    }

    void push_front(const _Ty& _Val) {
        _Emplace(_Mypair._Myval2._Myhead->_Next, _Val);
    }








#line 1249 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

    void pop_front() noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1252, 0, "%s", "pop_front called on empty list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"pop_front called on empty list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1252, 0); } while (false); } ; } while (false);
#line 1254 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

        _Unchecked_erase(_Mypair._Myval2._Myhead->_Next);
    }

    void push_back(const _Ty& _Val) {
        _Emplace(_Mypair._Myval2._Myhead, _Val);
    }








#line 1270 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

    void pop_back() noexcept  {

        do { if (_Mypair._Myval2._Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1273, 0, "%s", "pop_back called on empty list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"pop_back called on empty list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1273, 0); } while (false); } ; } while (false);
#line 1275 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
        }
    }

    template <class _Iter, class _Sent>
    void _Assign_unchecked(_Iter _First, const _Sent _Last) {
        
        const auto _Myend = _Mypair._Myval2._Myhead;
        auto _Old         = _Myend->_Next;
        for (;;) { 
            if (_First == _Last) {
                
                _Unchecked_erase(_Old, _Myend);
                return;
            }

            if (_Old == _Myend) { 
                _List_node_insert_op2<_Alnode> _Op(_Getal());
                _Op._Append_range_unchecked(::std:: move(_First), _Last);
                _Op._Attach_at_end(_Mypair._Myval2);
                return;
            }

            
            _Old->_Myval = *_First;
            _Old         = _Old->_Next;
            ++_First;
        }
    }

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));
    }






#line 1345 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

    void assign(__declspec(guard(overflow)) 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) { 

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1372, 0, "%s", "list insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1372, 0); } while (false); } ; } while (false);
#line 1374 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
        return _Make_iter(_Emplace(_Where._Ptr, _Val));
    }

    iterator insert(const_iterator _Where, __declspec(guard(overflow)) size_type _Count, const _Ty& _Val) {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1380, 0, "%s", "list insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1380, 0); } while (false); } ; } while (false);
#line 1382 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1390, 0, "%s", "list insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1390, 0); } while (false); } ; } while (false);
#line 1392 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }











#line 1409 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

    iterator erase(const const_iterator _Where) noexcept  {

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1412, 0, "%s", "list erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1412, 0); } while (false); } ; } while (false);
#line 1414 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

        const auto _Head = _Mypair._Myval2._Myhead;
        if (_First == _Head->_Next && _Last == _Head) { 
            _Mypair._Myval2._Orphan_non_end();
        } else { 
            _Lockit _Lock(3);
            for (auto _Marked = _First; _Marked != _Last; _Marked = _Marked->_Next) { 
                _Marked->_Prev = nullptr;
            }

            _Iterator_base12** _Pnext = &_Mypair._Myval2._Myproxy->_Myfirstiter;
            while (*_Pnext) {
                _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
                if (static_cast<const_iterator&>(**_Pnext)._Ptr->_Prev) { 
                    _Pnext = _Pnextnext;
                } else { 
                    (*_Pnext)->_Myproxy = nullptr;
                    *_Pnext             = *_Pnextnext;
                }
            }

            
        }
#line 1467 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 

            do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1517, 0, "%s", "list splice iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list splice iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1517, 0); } while (false); } ; } while (false);
#line 1519 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2) && _First._Getcont() == ::std:: addressof(_Right._Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1533, 0, "%s", "list splice iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list splice iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1533, 0); } while (false); } ; } while (false);
#line 1534 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
#line 1535 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
        const auto _UWhere = _Where._Ptr;
        const auto _UFirst = _First._Ptr;


        if (_UFirst == _Right._Mypair._Myval2._Myhead) {
            do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1540, 0, "%s", "list splice iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list splice iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1540, 0); } while (false);
        }
#line 1543 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        

        const auto _Right_data_ptr = ::std:: addressof(_Right._Mypair._Myval2);
        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2) && _First._Getcont() == _Right_data_ptr && _Last._Getcont() == _Right_data_ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1561, 0, "%s", "list splice iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list splice iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1561, 0); } while (false); } ; } while (false);
#line 1562 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
#line 1563 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {

                        do { if (_To_check != _Right_end) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1578, 0, "%s", "list bad splice")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list bad splice\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1578, 0); } while (false); } ; } while (false);
#line 1580 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, nullptr);
            const auto _Prev = _Removed->_Prev;
            _Prev->_Next     = _Next;
            _Next->_Prev     = _Prev;


            
            _Removed->_Prev = nullptr;
#line 1618 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

            *_Tail = _Removed;
            _Tail  = ::std:: addressof(_Removed->_Next);

            return _Next;
        }

        ~_List_node_remove_op() {
            auto& _Al = _List._Getal();


            {
                _Lockit _Lock(3);
                _Iterator_base12** _Pnext = &_List._Mypair._Myval2._Myproxy->_Myfirstiter;
                while (*_Pnext) {
                    _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
                    const auto _Pnextptr          = static_cast<const_iterator&>(**_Pnext)._Ptr;
                    if (_Pnextptr->_Prev) {
                        
                        _Pnext = _Pnextnext;
                    } else { 
                        (*_Pnext)->_Myproxy = nullptr;
                        *_Pnext             = *_Pnextnext;
                    }
                }
            }
#line 1645 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1687 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1714 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 

        _Debug_order_unchecked(_Unchecked_begin(), _Unchecked_end(), _Pred);
#line 1740 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
        if (this == ::std:: addressof(_Right)) {
            return;
        }


        _Debug_order_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end(), _Pred);
        if constexpr (!_Alnode_traits::is_always_equal::value) {
            do { if (_Getal() == _Right._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1747, 0, "%s", "list allocators incompatible for merge")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list allocators incompatible for merge\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1747, 0); } while (false); } ; } while (false);
        }
#line 1750 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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)) { 

            if constexpr (!_Alnode_traits::is_always_equal::value) {
                do { if (_Getal() == _Right._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1804, 0, "%s", "list allocators incompatible for splice")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"list allocators incompatible for splice\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list", 1804, 0); } while (false); } ; } while (false);
            }
#line 1807 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

            auto& _My_data = _Mypair._Myval2;
            if (max_size() - _My_data._Mysize < _Count) {
                _Xlength_error("list too long");
            }

            auto& _Right_data = _Right._Mypair._Myval2;

            
            if (_Count == 1) {
                _My_data._Adopt_unique(_Right_data, _First);
            } else if (_Count == _Right_data._Mysize) {
                _My_data._Adopt_all(_Right_data);
            } else {
                _My_data._Adopt_range(_Right_data, _First, _Last);
            }
#line 1824 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"

            _My_data._Mysize += _Count;
            _Right_data._Mysize -= _Count;
        }

        return _Scary_val::_Unchecked_splice(_Where, _First, _Last);
    }

    void _Alloc_sentinel_and_proxy() {
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _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 1863 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"





#line 1869 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1887 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1916 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1928 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"


namespace pmr {
     template <class _Ty>
    using list = ::std:: list<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 1935 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
}


#pragma warning(pop)
#pragma pack(pop)
#line 1941 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
#line 1942 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\list"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"





#pragma once









#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 34 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 51, 0, "%s", "can't dereference value-initialized vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference value-initialized vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 51, 0); } while (false); } ; } while (false);
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 52, 0, "%s", "can't dereference invalidated vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference invalidated vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 52, 0); } while (false); } ; } while (false);
        do { if (_Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 54, 0, "%s", "can't dereference out of range vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference out of range vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 54, 0); } while (false); } ; } while (false);
#line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 56 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *_Ptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {

        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 63, 0, "%s", "can't dereference value-initialized vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference value-initialized vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 63, 0); } while (false); } ; } while (false);
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 64, 0, "%s", "can't dereference invalidated vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference invalidated vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 64, 0); } while (false); } ; } while (false);
        do { if (_Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 66, 0, "%s", "can't dereference out of range vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference out of range vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 66, 0); } while (false); } ; } while (false);
#line 67 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 68 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return _Ptr;
    }

    constexpr _Vector_const_iterator& operator++() noexcept {

        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 75, 0, "%s", "can't increment value-initialized vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't increment value-initialized vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 75, 0); } while (false); } ; } while (false);
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 76, 0, "%s", "can't increment invalidated vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't increment invalidated vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 76, 0); } while (false); } ; } while (false);
        do { if (_Ptr < _Mycont->_Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 77, 0, "%s", "can't increment vector iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't increment vector iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 77, 0); } while (false); } ; } while (false);
#line 79 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 93, 0, "%s", "can't decrement value-initialized vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't decrement value-initialized vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 93, 0); } while (false); } ; } while (false);
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 94, 0, "%s", "can't decrement invalidated vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't decrement invalidated vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 94, 0); } while (false); } ; } while (false);
        do { if (_Mycont->_Myfirst < _Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 95, 0, "%s", "can't decrement vector iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't decrement vector iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 95, 0); } while (false); } ; } while (false);
#line 97 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {


#line 112 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
        do { if (_Off == 0 || _Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 113, 0, "%s", "cannot seek value-initialized vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 113, 0); } while (false); } ; } while (false);
        do { if (_Off == 0 || _Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 114, 0, "%s", "cannot seek invalidated vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek invalidated vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 114, 0); } while (false); } ; } while (false);
        if (_Off < 0) {
            do { if (_Off >= _Mycont->_Myfirst - _Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 116, 0, "%s", "cannot seek vector iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek vector iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 116, 0); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            do { if (_Off <= _Mycont->_Mylast - _Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 120, 0, "%s", "cannot seek vector iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek vector iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 120, 0); } while (false); } ; } while (false);
        }
#line 123 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _Vector_const_iterator operator+(
        const difference_type _Off, _Vector_const_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    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 194 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr void _Compat(const _Vector_const_iterator& _Right) const noexcept {
        


#line 200 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 200, 0, "%s", "vector iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 200, 0); } while (false); } ; } while (false);
#line 202 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
    }


    friend constexpr void _Verify_range(
        const _Vector_const_iterator& _First, const _Vector_const_iterator& _Last) noexcept {
        do { if (_First._Getcont() == _Last._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 207, 0, "%s", "vector iterators in range are from different containers")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector iterators in range are from different containers\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 207, 0); } while (false); } ; } while (false);
        do { if (_First._Ptr <= _Last._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 208, 0, "%s", "vector iterator range transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector iterator range transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 208, 0); } while (false); } ; } while (false);
    }
#line 211 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
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 {

        
        
        
        
        const auto _Mycont = static_cast<const _Myvec*>(_Iter._Getcont());
        if (_Mycont) {
            do { if (_Mycont->_Myfirst <= _Iter._Ptr && _Iter._Ptr <= _Mycont->_Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 241, 0, "%s", "can't convert out-of-range vector iterator to pointer")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't convert out-of-range vector iterator to pointer\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 241, 0); } while (false); } ; } while (false);
#line 242 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        } else {
            do { if (!_Iter._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 243, 0, "%s", "can't convert invalid vector iterator to pointer")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't convert invalid vector iterator to pointer\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 243, 0); } while (false); } ; } while (false);
        }
#line 246 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return ::std:: to_address(_Iter._Ptr);
    }
};
#line 251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 260 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
        do { if (this->_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 275, 0, "%s", "can't dereference value-initialized vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference value-initialized vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 275, 0); } while (false); } ; } while (false);
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 276, 0, "%s", "can't dereference invalidated vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference invalidated vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 276, 0); } while (false); } ; } while (false);
        do { if (_Mycont->_Myfirst <= this->_Ptr && this->_Ptr < _Mycont->_Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 278, 0, "%s", "can't dereference out of range vector iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't dereference out of range vector iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 278, 0); } while (false); } ; } while (false);
#line 279 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 280 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _Vector_iterator operator+(
        const difference_type _Off, _Vector_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    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>
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 {

        
        
        
        
        const auto _Mycont = static_cast<const _Myvec*>(_Iter._Getcont());
        if (_Mycont) {
            do { if (_Mycont->_Myfirst <= _Iter._Ptr && _Iter._Ptr <= _Mycont->_Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 363, 0, "%s", "can't convert out-of-range vector iterator to pointer")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't convert out-of-range vector iterator to pointer\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 363, 0); } while (false); } ; } while (false);
#line 364 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        } else {
            do { if (!_Iter._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 365, 0, "%s", "can't convert invalid vector iterator to pointer")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"can't convert invalid vector iterator to pointer\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 365, 0); } while (false); } ; } while (false);
        }
#line 368 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return ::std:: to_address(_Iter._Ptr);
    }
};
#line 373 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer>
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(_Myfirst, _Right._Myfirst); 
        swap(_Mylast, _Right._Mylast); 
        swap(_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;
}

 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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
                                    "because of [container.requirements].");

    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 600 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>>>;

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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
    }

    constexpr explicit vector(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
    }

    constexpr explicit vector(__declspec(guard(overflow)) const size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_n(_Count);
    }

    constexpr vector(__declspec(guard(overflow)) 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_cpp17_fwd_iter_v<_Iter>) {
            const auto _Length = static_cast<size_t>(::std:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            _Construct_n(_Count, ::std:: move(_UFirst), ::std:: move(_ULast));

        } else if constexpr (forward_iterator<_Iter>) {
            const auto _Length = _To_unsigned_like(::std::ranges:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            _Construct_n(_Count, ::std:: move(_UFirst), ::std:: move(_ULast));
#line 644 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        } else {
            auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
            _Tidy_guard<vector> _Guard{this};

            _Append_uncounted_range(::std:: move(_UFirst), ::std:: move(_ULast));

            _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());
    }




















#line 681 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal()));
        _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   = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al);
        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();

        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                
                _Mypair._Myval2._Reload_proxy(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al), static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Right_al));
            }
        }
#line 760 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        _Pocma(_Al, _Right_al);
        _Mypair._Myval2._Take_contents(_Right._Mypair._Myval2);
        return *this;
    }

    constexpr ~vector() noexcept {
        _Tidy();

        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
        _Delete_plain_internal(_Alproxy, ::std:: exchange(_Mypair._Myval2._Myproxy, nullptr));
#line 772 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
        size_type _Newcapacity   = _Calculate_growth(_Newsize);

        const pointer _Newvec           = _Allocate_at_least_helper(_Al, _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 870 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
    }

    constexpr void push_back(const _Ty& _Val) { 
        _Emplace_one_at_back(_Val);
    }

    constexpr void push_back(_Ty&& _Val) {
        
        _Emplace_one_at_back(::std:: move(_Val));
    }

private:
    template <class _Iter, class _Sent>
    constexpr void _Append_uncounted_range(_Iter _First, const _Sent _Last) {
        

        
        
        

        for (; _First != _Last; ++_First) {
            _Emplace_one_at_back(*_First);
        }
    }


























































#line 953 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

public:











#line 967 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    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;

        do { if (_Where._Getcont() == ::std:: addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Oldlast >= _Whereptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 977, 0, "%s", "vector emplace iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector emplace iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 977, 0); } while (false); } ; } while (false);
#line 978 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 979 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, __declspec(guard(overflow)) 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;

        do { if (_Where._Getcont() == ::std:: addressof(_My_data) && _Whereptr >= _Oldfirst && _Oldlast >= _Whereptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1022, 0, "%s", "vector insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1022, 0); } while (false); } ; } while (false);
#line 1023 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1024 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
            size_type _Newcapacity   = _Calculate_growth(_Newsize);

            const pointer _Newvec           = _Allocate_at_least_helper(_Al, _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_n(_Whereptr, _Count, _Tmp);
            }
            ;
        }

        return _Make_iterator_offset(_Whereoff);
    }

private:
    template <class _Iter, class _Sent>
    constexpr void _Insert_uncounted_range(const_iterator _Where, _Iter _First, _Sent _Last) {
        
        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);

        _Append_uncounted_range(::std:: move(_First), ::std:: move(_Last));

        _Orphan_range(_Myfirst + _Whereoff, _Myfirst + _Oldsize);

        ::std:: rotate(_Myfirst + _Whereoff, _Myfirst + _Oldsize, _Mylast);
    }

    template <class _Iter>
    constexpr void _Insert_counted_range(const_iterator _Where, _Iter _First, const size_type _Count) {
        
        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;
        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;
            size_type _Newcapacity   = _Calculate_growth(_Newsize);

            const pointer _Newvec           = _Allocate_at_least_helper(_Al, _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_n(::std:: move(_First), _Count, _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_n(::std:: move(_First), _Count, _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;
                }

                ::std:: _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_n(::std:: move(_First), _Count, _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;

        do { if (_Where._Getcont() == ::std:: addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1233, 0, "%s", "vector insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1233, 0); } while (false); } ; } while (false);
#line 1234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1235 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        _Adl_verify_range(_First, _Last);
        auto _UFirst         = _Get_unwrapped(_First);
        auto _ULast          = _Get_unwrapped(_Last);
        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
            const auto _Length = static_cast<size_t>(::std:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            _Insert_counted_range(_Where, _UFirst, _Count);

        } else if constexpr (forward_iterator<_Iter>) {
            const auto _Length = _To_unsigned_like(::std::ranges:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            _Insert_counted_range(_Where, _UFirst, _Count);
#line 1250 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        } else {
            _Insert_uncounted_range(_Where, _UFirst, _ULast);
        }
        return _Make_iterator_offset(_Whereoff);
    }























#line 1279 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
        const pointer _Whereptr = _Where._Ptr;
        auto& _My_data          = _Mypair._Myval2;
        const pointer _Oldfirst = _My_data._Myfirst;

        do { if (_Where._Getcont() == ::std:: addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1287, 0, "%s", "vector insert iterator out-of-range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector insert iterator out-of-range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1287, 0); } while (false); } ; } while (false);
#line 1288 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1289 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);

        const auto _Count = _Convert_size<size_type>(_Ilist.size());
        _Insert_counted_range(_Where, _Ilist.begin(), _Count);
        return _Make_iterator_offset(_Whereoff);
    }

    constexpr void assign(__declspec(guard(overflow)) 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;



        if (!::std:: is_constant_evaluated())
#line 1307 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        {
            const auto _Valptr = ::std:: addressof(_Val);
            do { if (!(_Unfancy(_Myfirst) <= _Valptr && _Valptr < _Unfancy(_Mylast))) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1310, 0, "%s", "assignment value cannot be a reference into the container")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"assignment value cannot be a reference into the container\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1310, 0); } while (false); } ; } while (false);
#line 1311 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        }
#line 1313 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        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, class _Sent>
    constexpr void _Assign_uncounted_range(_Iter _First, _Sent _Last) {
        
        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;

        _Append_uncounted_range(::std:: move(_First), ::std:: move(_Last));
    }

    template <class _Iter>
    constexpr void _Assign_counted_range(_Iter _First, 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;

        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_n(::std:: move(_First), _Newsize, _Myfirst, _Al);
                ;
            } else {
                ;
                _Mylast = _Uninitialized_copy_n(::std:: move(_First), _Newsize, _Myfirst, _Al);
            }
            return;
        }

        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
        if (_Newsize > _Oldsize) {
            bool _Copied = false;
            if constexpr (_Iter_copy_cat<_Iter, pointer>::_Bitcopy_assignable) {

                if (!::std:: is_constant_evaluated())
#line 1413 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
                {
                    _Copy_memmove_n(_First, static_cast<size_t>(_Oldsize), _Myfirst);
                    _First += _Oldsize;
                    _Copied = true;
                }
            }

            if (!_Copied) {
                for (auto _Mid = _Myfirst; _Mid != _Mylast; ++_Mid, (void) ++_First) {
                    *_Mid = *_First;
                }
            }

            if constexpr (_Nothrow_construct) {
                ;
                _Mylast = _Uninitialized_copy_n(::std:: move(_First), _Newsize - _Oldsize, _Mylast, _Al);
            } else {
                ;
                _Mylast = _Uninitialized_copy_n(::std:: move(_First), _Newsize - _Oldsize, _Mylast, _Al);
                ;
            }
        } else {
            const pointer _Newlast = _Myfirst + _Newsize;
            _Copy_n_unchecked4(::std:: move(_First), _Newsize, _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);
        auto _UFirst = _Get_unwrapped(_First);
        auto _ULast  = _Get_unwrapped(_Last);
        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
            const auto _Length = static_cast<size_t>(::std:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            _Assign_counted_range(_UFirst, _Count);

        } else if constexpr (forward_iterator<_Iter>) {
            const auto _Length = _To_unsigned_like(::std::ranges:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            _Assign_counted_range(_UFirst, _Count);
#line 1459 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        } else {
            _Assign_uncounted_range(_UFirst, _ULast);
        }
    }












#line 1476 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr void assign(const initializer_list<_Ty> _Ilist) {
        const auto _Count = _Convert_size<size_type>(_Ilist.size());
        _Assign_counted_range(_Ilist.begin(), _Count);
    }

    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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al), static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Right_al));
            }
        }

        _Pocca(_Al, _Right_al);
        auto& _Right_data = _Right._Mypair._Myval2;
        _Assign_counted_range(_Right_data._Myfirst, static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst));

        return *this;
    }

    constexpr vector& operator=(initializer_list<_Ty> _Ilist) {
        const auto _Count = _Convert_size<size_type>(_Ilist.size());
        _Assign_counted_range(_Ilist.begin(), _Count);
        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);
        size_type _Newcapacity = _Calculate_growth(_Newsize);

        const pointer _Newvec         = _Allocate_at_least_helper(_Al, _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(__declspec(guard(overflow)) const size_type _Newsize) {
        
        _Resize(_Newsize, _Value_init_tag{});
    }

    constexpr void resize(__declspec(guard(overflow)) const size_type _Newsize, const _Ty& _Val) {
        
        _Resize(_Newsize, _Val);
    }

private:
    enum class _Reallocation_policy { _At_least, _Exactly };

    template <_Reallocation_policy _Policy>
    constexpr void _Reallocate(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);

        pointer _Newvec;
        if constexpr (_Policy == _Reallocation_policy::_At_least) {
            _Newvec = _Allocate_at_least_helper(_Al, _Newcapacity);
        } else {
            ;
            _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 1654 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1666 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(__declspec(guard(overflow)) size_type _Newcapacity) {
        
        if (_Newcapacity > capacity()) { 
            if (_Newcapacity > max_size()) {
                _Xlength();
            }

            _Reallocate<_Reallocation_policy::_At_least>(_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 {
                size_type _Newcapacity = static_cast<size_type>(_Oldlast - _Oldfirst);
                _Reallocate<_Reallocation_policy::_Exactly>(_Newcapacity);
            }
        }
    }

    constexpr void pop_back() noexcept  {
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;


        do { if (_My_data._Myfirst != _Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1717, 0, "%s", "vector empty before pop")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector empty before pop\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1717, 0); } while (false); } ; } while (false);
#line 1719 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;


        do { if (_Where._Getcont() == ::std:: addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Mylast > _Whereptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1735, 0, "%s", "vector erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1735, 0); } while (false); } ; } while (false);
#line 1736 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1737 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        _Orphan_range(_Whereptr, _Mylast);
        ::std:: _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;


        do { if (_First._Getcont() == ::std:: addressof(_My_data) && _Last._Getcont() == ::std:: addressof(_My_data) && _Firstptr >= _My_data._Myfirst && _Lastptr >= _Firstptr && _Mylast >= _Lastptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1756, 0, "%s", "vector erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1756, 0); } while (false); } ; } while (false);
#line 1757 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1758 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        if (_Firstptr != _Lastptr) { 
            _Orphan_range(_Firstptr, _Mylast);

            const pointer _Newlast = ::std:: _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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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;

        do { if (_Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1896, 0, "%s", "vector subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1896, 0); } while (false); } ; } while (false);
#line 1897 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1898 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return _My_data._Myfirst[_Pos];
    }

    [[nodiscard]] constexpr const _Ty& operator[](const size_type _Pos) const noexcept  {
        auto& _My_data = _Mypair._Myval2;

        do { if (_Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1906, 0, "%s", "vector subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1906, 0); } while (false); } ; } while (false);
#line 1907 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 1908 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

        do { if (_My_data._Myfirst != _My_data._Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1933, 0, "%s", "front() called on empty vector")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty vector\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1933, 0); } while (false); } ; } while (false);
#line 1935 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *_My_data._Myfirst;
    }

    [[nodiscard]] constexpr const _Ty& front() const noexcept  {
        auto& _My_data = _Mypair._Myval2;

        do { if (_My_data._Myfirst != _My_data._Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1942, 0, "%s", "front() called on empty vector")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty vector\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1942, 0); } while (false); } ; } while (false);
#line 1944 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *_My_data._Myfirst;
    }

    [[nodiscard]] constexpr _Ty& back() noexcept  {
        auto& _My_data = _Mypair._Myval2;

        do { if (_My_data._Myfirst != _My_data._Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1951, 0, "%s", "back() called on empty vector")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty vector\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1951, 0); } while (false); } ; } while (false);
#line 1953 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return _My_data._Mylast[-1];
    }

    [[nodiscard]] constexpr const _Ty& back() const noexcept  {
        auto& _My_data = _Mypair._Myval2;

        do { if (_My_data._Myfirst != _My_data._Mylast) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1960, 0, "%s", "back() called on empty vector")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty vector\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 1960, 0); } while (false); } ; } while (false);
#line 1962 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(size_type _Newcapacity) {
        
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;
        pointer& _Myend   = _My_data._Myend;

        ; 
        ;

        const pointer _Newvec = _Allocate_at_least_helper(_Getal(), _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(__declspec(guard(overflow)) const size_type _Count, _Valty&&... _Val) {
        
        
        
        
        auto& _Al       = _Getal();
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al);
        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;
            ::std:: _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;
            ::std:: _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");
    }


    constexpr void _Orphan_range_unlocked(pointer _First, pointer _Last) const {
        _Iterator_base12** _Pnext = &_Mypair._Myval2._Myproxy->_Myfirstiter;
        while (*_Pnext) {
            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
            const auto _Temp     = *_Pnext;
            if (_Pnextptr < _First || _Last < _Pnextptr) { 
                _Pnext = &_Temp->_Mynextiter;
            } else { 
                _Temp->_Myproxy = nullptr;
                *_Pnext         = _Temp->_Mynextiter;
            }
        }
    }

    void _Orphan_range_locked(pointer _First, pointer _Last) const {
        _Lockit _Lock(3);
        _Orphan_range_unlocked(_First, _Last);
    }

    constexpr void _Orphan_range(pointer _First, pointer _Last) const {
        

        if (::std:: is_constant_evaluated()) {
            _Orphan_range_unlocked(_First, _Last);
        } else
#line 2182 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        {
            _Orphan_range_locked(_First, _Last);
        }
    }


#line 2189 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2216 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"





#line 2222 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

template <class _Alloc>
class vector<bool, _Alloc>;

using _Vbase = unsigned int; 

inline 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 2250 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2277 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2290 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2361 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2378 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>>;

    static constexpr _Difference_type _VBITS_DIFF = _VBITS;

    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;
    }


    constexpr _Difference_type _Total_off(const _Mycont* _Cont) const noexcept {
        return static_cast<_Difference_type>(_VBITS_DIFF * (_Myptr - _Cont->_Myvec.data()) + _Myoff);
    }
#line 2413 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    const _Vbase* _Myptr = nullptr;
    _Size_type _Myoff    = 0;
};

template <class _Alvbase_wrapped>
class _Vb_reference : public _Vb_iter_base<_Alvbase_wrapped> {
    
private:
    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;
    }











#line 2460 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr void flip() noexcept {
        *const_cast<_Vbase*>(_Getptr()) ^= _Mask();
    }

    constexpr operator bool() const noexcept {
        return (*_Getptr() & _Mask()) != 0;
    }

    constexpr const _Vbase* _Getptr() const noexcept {

        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
        do { if (_Cont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2472, 0, "%s", "cannot dereference value-initialized vector<bool> iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized vector<bool> iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2472, 0); } while (false); } ; } while (false);
        do { if (this->_Total_off(_Cont) <= static_cast<_Difference_type>(_Cont->_Mysize)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2474, 0, "%s", "vector<bool> iterator not dereferenceable")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> iterator not dereferenceable\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2474, 0); } while (false); } ; } while (false);
#line 2475 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 2476 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
        do { if (_Cont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2518, 0, "%s", "cannot dereference value-initialized vector<bool> iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized vector<bool> iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2518, 0); } while (false); } ; } while (false);
        do { if (this->_Total_off(_Cont) < static_cast<_Difference_type>(_Cont->_Mysize)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2520, 0, "%s", "vector<bool> iterator not dereferenceable")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> iterator not dereferenceable\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2520, 0); } while (false); } ; } while (false);
#line 2521 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 2522 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        if (_Off != 0) {
            const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
            do { if (_Cont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2552, 0, "%s", "cannot seek value-initialized vector<bool> iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized vector<bool> iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2552, 0); } while (false); } ; } while (false);
            const auto _Start_offset = this->_Total_off(_Cont);
            if (_Off < 0) {
                do { if (-_Start_offset <= _Off) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2555, 0, "%s", "cannot seek vector<bool> iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek vector<bool> iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2555, 0); } while (false); } ; } while (false);
            } else if (0 < _Off) {
                do { if (_Off <= static_cast<_Difference_type>(_Cont->_Mysize - _Start_offset)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2558, 0, "%s", "cannot seek vector<bool> iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek vector<bool> iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2558, 0); } while (false); } ; } while (false);
#line 2559 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
            }
        }
#line 2562 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _Vb_const_iterator operator+(
        const difference_type _Off, _Vb_const_iterator _Right) noexcept {
        _Right += _Off;
        return _Right;
    }

    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>(_Mybase::_VBITS_DIFF * (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 2642 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr void _Compat(const _Vb_const_iterator& _Right) const noexcept {
        


#line 2648 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2648, 0, "%s", "vector<bool> iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2648, 0); } while (false); } ; } while (false);
#line 2650 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
    }


    using _Prevent_inheriting_unwrap = _Vb_const_iterator;

    friend constexpr void _Verify_range(const _Vb_const_iterator& _First, const _Vb_const_iterator& _Last) noexcept {
        
        do { if (_First <= _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2657, 0, "%s", "vector<bool> iterator range transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> iterator range transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2657, 0); } while (false); } ; } while (false);
    }
#line 2660 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr void _Dec() noexcept { 

        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
        do { if (_Cont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2664, 0, "%s", "cannot decrement value-initialized vector<bool> iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized vector<bool> iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2664, 0); } while (false); } ; } while (false);
        do { if (this->_Total_off(_Cont) > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2665, 0, "%s", "cannot decrement vector<bool> begin iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement vector<bool> begin iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2665, 0); } while (false); } ; } while (false);
#line 2667 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        if (this->_Myoff != 0) {
            --this->_Myoff;
        } else { 
            this->_Myoff = _VBITS - 1;
            --this->_Myptr;
        }
    }

    constexpr void _Inc() noexcept { 

        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
        do { if (_Cont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2679, 0, "%s", "cannot increment value-initialized vector<bool> iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized vector<bool> iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2679, 0); } while (false); } ; } while (false);
        do { if (this->_Total_off(_Cont) < static_cast<_Difference_type>(_Cont->_Mysize)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2681, 0, "%s", "cannot increment vector<bool> end iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment vector<bool> end iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2681, 0); } while (false); } ; } while (false);
#line 2682 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 2683 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        if (this->_Myoff < _VBITS - 1) {
            ++this->_Myoff;
        } else { 
            this->_Myoff = 0;
            ++this->_Myptr;
        }
    }
};

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 {

        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
        do { if (_Cont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2714, 0, "%s", "cannot dereference value-initialized vector<bool> iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized vector<bool> iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2714, 0); } while (false); } ; } while (false);
        do { if (this->_Total_off(_Cont) < static_cast<_Difference_type>(_Cont->_Mysize)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2716, 0, "%s", "vector<bool> iterator not dereferenceable")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> iterator not dereferenceable\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 2716, 0); } while (false); } ; } while (false);
#line 2717 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 2718 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _Vb_iterator operator+(const difference_type _Off, _Vb_iterator _Right) noexcept {
        _Right += _Off;
        return _Right;
    }

    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 _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(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    constexpr _Vb_val(const _Alloc& _Al) noexcept : _Myvec(static_cast<_Alvbase>(_Al)), _Mysize(0) {
        this->_Alloc_proxy(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    constexpr _Vb_val(size_type _Count, const bool& _Val)
        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0)), _Mysize(0) {
        this->_Alloc_proxy(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    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(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    constexpr _Vb_val(const _Vb_val& _Right) : _Myvec(_Right._Myvec), _Mysize(_Right._Mysize) {
        this->_Alloc_proxy(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    constexpr _Vb_val(const _Vb_val& _Right, const _Alloc& _Al)
        : _Myvec(_Right._Myvec, static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
        this->_Alloc_proxy(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    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(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    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(static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(_Getal()));
    }

    constexpr ~_Vb_val() noexcept {

        this->_Orphan_all();
        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alvbase, _Container_proxy>>(this->_Getal());
        _Delete_plain_internal(_Alproxy, ::std:: exchange(this->_Myproxy, nullptr));
#line 2838 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    constexpr void _Emplace_back_unchecked(const _Vbase _Val) noexcept {
        ;
        _Myvec._Emplace_back_with_unused_capacity(_Val);
    }

    _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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");

    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>;

    enum { _EEN_VBITS = _VBITS }; 

    constexpr vector() noexcept(is_nothrow_default_constructible_v<_Alloc>) : _Mybase(_Alloc()) {}

    constexpr explicit vector(const _Alloc& _Al) noexcept : _Mybase(_Al) {}

    constexpr explicit vector(__declspec(guard(overflow)) size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mybase(_Count, false, _Al) {
        _Trim(_Count);
    }

    constexpr vector(__declspec(guard(overflow)) 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) {
        insert(begin(), _First, _Last);
    }












#line 2926 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr vector(vector&& _Right) noexcept : _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);
    }

    constexpr vector& operator=(vector&& _Right) noexcept(
        _Choose_pocma_v<_Alvbase> != _Pocma_values::_No_propagate_allocators) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }




#line 2953 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        this->_Orphan_all();
        auto& _Al                 = this->_Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alvbase>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            using _Alproxy_type = _Rebind_alloc_t<_Alvbase, _Container_proxy>;
            if (_Al != _Right_al) { 
                
                _Alproxy_type _Oldal(_Al);
                _Alproxy_type _Right_proxy_al(_Right_al);
                _Container_proxy_ptr<_Alvbase> _Proxy(_Right_proxy_al, _Leave_proxy_unbound{});
                this->_Myvec  = ::std:: move(_Right._Myvec);
                this->_Mysize = ::std:: exchange(_Right._Mysize, size_type{0});
                _Proxy._Bind(_Oldal, this);
                this->_Swap_proxy_and_iterators(_Right);
                return *this;
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            this->_Myvec  = ::std:: move(_Right._Myvec);
            this->_Mysize = _Right._Mysize;
            if (_Right._Myvec.empty()) {
                
                _Right._Mysize = 0;
            }

            if (_Al == _Right_al) {
                this->_Swap_proxy_and_iterators(_Right);
            }
            return *this;
        }

        this->_Myvec  = ::std:: move(_Right._Myvec);
        this->_Mysize = ::std:: exchange(_Right._Mysize, size_type{0});
        this->_Swap_proxy_and_iterators(_Right);

#line 2989 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3000 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {}

    constexpr vector& operator=(const vector& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }




#line 3036 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        this->_Orphan_all();
        auto& _Al       = this->_Getal();
        auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alvbase>) {
            if (_Al != _Right_al) {
                
                using _Alproxy_type = _Rebind_alloc_t<_Alvbase, _Container_proxy>;
                _Alproxy_type _Oldal(_Al);
                _Alproxy_type _Right_proxy_al(_Right_al);
                _Container_proxy_ptr<_Alvbase> _Proxy(_Right_proxy_al, _Leave_proxy_unbound{});
                this->_Myvec  = _Right._Myvec;
                this->_Mysize = _Right._Mysize;
                _Proxy._Bind(_Oldal, this);
                return *this;
            }
        }

        this->_Myvec  = _Right._Myvec;
        this->_Mysize = _Right._Mysize;
#line 3056 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *this;
    }

    constexpr void reserve(__declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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  {

        do { if (_Off < this->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3197, 0, "%s", "vector<bool> subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3197, 0); } while (false); } ; } while (false);
#line 3199 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        const_iterator _It = begin();
        _It._Advance(_Off);
        return *_It;
    }

    [[nodiscard]] constexpr reference operator[](size_type _Off) noexcept  {

        do { if (_Off < this->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3207, 0, "%s", "vector<bool> subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3207, 0); } while (false); } ; } while (false);
#line 3209 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        iterator _It = begin();
        _It._Advance(_Off);
        return *_It;
    }

    [[nodiscard]] constexpr reference front() noexcept  {

        do { if (this->_Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3217, 0, "%s", "front() called on empty vector<bool>")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty vector<bool>\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3217, 0); } while (false); } ; } while (false);
#line 3219 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *begin();
    }

    [[nodiscard]] constexpr const_reference front() const noexcept  {

        do { if (this->_Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3225, 0, "%s", "front() called on empty vector<bool>")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty vector<bool>\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3225, 0); } while (false); } ; } while (false);
#line 3227 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *begin();
    }

    [[nodiscard]] constexpr reference back() noexcept  {

        do { if (this->_Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3233, 0, "%s", "back() called on empty vector<bool>")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty vector<bool>\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3233, 0); } while (false); } ; } while (false);
#line 3235 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *(end() - 1);
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {

        do { if (this->_Mysize != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3241, 0, "%s", "back() called on empty vector<bool>")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty vector<bool>\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3241, 0); } while (false); } ; } while (false);
#line 3243 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        return *(end() - 1);
    }

    constexpr void push_back(const bool& _Val) {
        insert(end(), _Val);
    }






#line 3257 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    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);
    }



























































#line 3327 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr void assign(__declspec(guard(overflow)) 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, size_type{1}, _Val);
    }

    constexpr iterator insert(const_iterator _Where, __declspec(guard(overflow)) 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) {
        const difference_type _Saved_offset = _Where - begin();
        _Adl_verify_range(_First, _Last);
        auto _UFirst      = _Get_unwrapped(_First);
        const auto _ULast = _Get_unwrapped(_Last);

        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
            const auto _Length = static_cast<size_t>(::std:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
            ::std:: _Copy_unchecked(_UFirst, _ULast, begin() + _Off);

        } else if constexpr (forward_iterator<_Iter>) {
            const auto _Length = _To_unsigned_like(::std::ranges:: distance(_UFirst, _ULast));
            const auto _Count  = _Convert_size<size_type>(_Length);
            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
            ::std:: _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
#line 3360 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        } else {
            const auto _Old_size = this->_Mysize;
            for (; _UFirst != _ULast; ++_UFirst) {
                emplace_back(*_UFirst);
            }

            _Orphan_range(static_cast<size_type>(_Saved_offset), _Old_size);
#line 3368 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
            ::std:: rotate(begin() + _Saved_offset, begin() + static_cast<difference_type>(_Old_size), end());
        }

        return begin() + _Saved_offset;
    }


























#line 3400 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

    constexpr iterator erase(const_iterator _Where_arg) noexcept  {
        iterator _Where      = _Make_iter(_Where_arg);
        difference_type _Off = _Where - begin();


        do { if (end() > _Where) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3406, 0, "%s", "vector<bool> erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3406, 0); } while (false); } ; } while (false);
        ::std:: copy(_Next_iter(_Where), end(), _Where);
        _Orphan_range(static_cast<size_type>(_Off), this->_Mysize);



#line 3413 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 

            do { if (_Last >= _First && end() >= _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3426, 0, "%s", "vector<bool> erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3426, 0); } while (false); } ; } while (false);
            iterator _Next      = ::std:: copy(_Last, end(), _First);
            const auto _Newsize = static_cast<size_type>(_Next - begin());
            _Orphan_range(_Newsize, this->_Mysize);
            _Trim(_Newsize);




#line 3436 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_n(_Result, _Count, _Val);
        return _Result;
    }

    constexpr size_type _Insert_x(const_iterator _Where, size_type _Count) {
        const difference_type _Off = _Where - begin();


        do { if (end() >= _Where) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3481, 0, "%s", "vector<bool> insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"vector<bool> insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector", 3481, 0); } while (false); } ; } while (false);
        const bool _Realloc = capacity() - size() < _Count;
#line 3484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"

        if (_Count != 0) {
            if (max_size() - size() < _Count) {
                _Xlen(); 
            }


            _Orphan_range(static_cast<size_type>(_Realloc ? 0 : _Off), this->_Mysize);
#line 3493 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
            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());
            }
        }

        return static_cast<size_type>(_Off);
    }


    constexpr void _Orphan_range_unlocked(size_type _Offlo, size_type _Offhi) const {
        const auto _Base = this->_Myvec.data();

        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
        while (*_Pnext) { 
            const auto& _Pnextiter = static_cast<const_iterator&>(**_Pnext);
            const auto _Temp       = *_Pnext;
            if (!_Pnextiter._Myptr) { 
                _Temp->_Myproxy = nullptr;
                *_Pnext         = _Temp->_Mynextiter;
                continue;
            }
            const auto _Off =
                static_cast<size_type>(const_iterator::_VBITS_DIFF * (_Pnextiter._Myptr - _Base)) + _Pnextiter._Myoff;
            if (_Off < _Offlo || _Offhi < _Off) {
                _Pnext = &_Temp->_Mynextiter;
            } else { 
                _Temp->_Myproxy = nullptr;
                *_Pnext         = _Temp->_Mynextiter;
            }
        }
    }

    void _Orphan_range_locked(size_type _Offlo, size_type _Offhi) const {
        _Lockit _Lock(3);
        _Orphan_range_unlocked(_Offlo, _Offhi);
    }

    constexpr void _Orphan_range(size_type _Offlo, size_type _Offhi) const {

        if (::std:: is_constant_evaluated()) {
            _Orphan_range_unlocked(_Offlo, _Offhi);
        } else
#line 3541 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
        {
            _Orphan_range_locked(_Offlo, _Offhi);
        }
    }
#line 3546 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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]] static void _Xlen() {
        _Xlength_error("vector<bool> too long");
    }

    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid vector<bool> subscript");
    }
};

template <class _Alloc>
struct hash<vector<bool, _Alloc>> {
    using _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 suppress this warning.")]] = vector<bool, _Alloc>;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[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 3589 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3630 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3749 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#line 3750 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\vector"
#pragma external_header(pop)
#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;














    _BitScanReverse64(&_Result, _Value); 


#line 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xbit_ops.h"
#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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; 


    if (_BitScanReverse64(&_Index, _Value)) {
        return _Index + 1;
    }












#line 86 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xbit_ops.h"

    return 0;
}

}



#pragma warning(pop)
#pragma pack(pop)
#line 97 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xbit_ops.h"
#line 98 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xbit_ops.h"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"








#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xnode_handle.h"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_storage_t<sizeof(_Alloc), alignof(_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  {
        using ::std:: swap;
        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(_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 216 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xnode_handle.h"
#line 217 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xnode_handle.h"
#pragma external_header(pop)
#line 25 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"
#line 26 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 std {
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,
    enable_if_t<conjunction_v<_Is_transparent<_Hasher>, _Is_transparent<_Keyeq>>>> {
    
    template <class _Keyty>
    using _Deduce_key = const _Keyty&;

    template <class _Container, class _Kx>
    static constexpr bool _Supports_transparency =
        !disjunction_v<is_convertible<_Kx, typename _Container::const_iterator>,
            is_convertible<_Kx, typename _Container::iterator>>;
};
#line 122 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>>) {
        using ::std:: swap;
        swap(_Mypair._Get_first(), _Rhs._Mypair._Get_first()); 
        auto& _Lsecond = _Mypair._Myval2;
        auto& _Rsecond = _Rhs._Mypair._Myval2;
        swap(_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 211 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>>>;

    _Hash_vec() : _Mypair(_Zero_then_variadic_args_t{}) {
        _Mypair._Myval2._Alloc_proxy(static_cast<_Rebind_alloc_t<_Aliter, _Container_proxy>>(_Mypair._Get_first()));
    }

    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(static_cast<_Rebind_alloc_t<_Aliter, _Container_proxy>>(_Mypair._Get_first()));
    }

    _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()));
    }

    [[nodiscard]] size_type capacity() const noexcept {
        
        
        return static_cast<size_type>(_Mypair._Myval2._Myend - _Mypair._Myval2._Myfirst);
    }

    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); 
            
            const auto _Oldcapacity = capacity();
            if (_Oldcapacity != 0) {
                _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
                _Alvec.deallocate(_Mypair._Myval2._Myfirst, _Oldcapacity);
            }

            _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 {
        if (_Mypair._Myval2._Myfirst != nullptr) {
            _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
            _Mypair._Get_first().deallocate(_Mypair._Myval2._Myfirst, capacity());
            _Mypair._Myval2._Myfirst = nullptr;
            _Mypair._Myval2._Mylast  = nullptr;
            _Mypair._Myval2._Myend   = nullptr;
        }
    }

    ~_Hash_vec() {
        _Tidy();

        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Aliter, _Container_proxy>>(_Mypair._Get_first());
        _Delete_plain_internal(_Alproxy, ::std:: exchange(_Mypair._Myval2._Myproxy, nullptr));
#line 329 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_range_unchecked(_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       = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al);
                auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al);
                _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       = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al);
                auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al);
                _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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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  {
        do { if (!(:: isnan)(_Newmax) && _Newmax > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 917, 0, "%s", "invalid hash load factor")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid hash load factor\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 917, 0); } while (false); } ; } while (false);
        _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(_Min_load_factor_buckets(_Maxcount));
    }

    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));
    }

protected:
    template <class _Iter, class _Sent>
    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
        for (; _First != _Last; ++_First) {
            emplace(*_First);
        }
    }

public:
    template <class _Iter>
    void insert(_Iter _First, _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        _Insert_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }






#line 972 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"

    void insert(initializer_list<value_type> _Ilist) {
        _Insert_range_unchecked(_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;


        
        
        _Range_eraser(_Mylist& _List_, const _Nodeptr _First_) noexcept
            : _List(_List_), _First(_First_), _Next(_First_) {}

        void _Bump_erased() noexcept {
            _Next = _Next->_Next;
        }

        ~_Range_eraser() noexcept {
            _List._Unchecked_erase(_First, _Next);
        }

        _Mylist& _List;
        const _Nodeptr _First;
        _Nodeptr _Next;




















#line 1026 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }







#line 1151 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1244 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 warning.")]] [[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 warning.")]] [[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 warning.")]] [[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 warning.")]] [[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) {

        const auto _List_data = ::std:: addressof(_List._Mypair._Myval2);
        do { if (_Where._Getcont() == _List_data) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1368, 0, "%s", "extract mismatched container")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"extract mismatched container\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1368, 0); } while (false); } ; } while (false);
        do { if (_Where._Ptr != _List_data->_Myhead) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1369, 0, "%s", "cannot extract end()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot extract end()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1369, 0); } while (false); } ; } while (false);
#line 1371 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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());
    }












#line 1396 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"

    iterator insert(const_iterator _Hint, node_type&& _Handle) {
        if (_Handle.empty()) {
            return end();
        }


        do { if (_List.get_allocator() == _Handle._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1403, 0, "%s", "node handle allocator incompatible for insert")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"node handle allocator incompatible for insert\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1403, 0); } while (false); } ; } while (false);
#line 1405 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
            }
        }


        if constexpr (!_Alnode_traits::is_always_equal::value) {
            do { if (_List._Getal() == _That._List._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1446, 0, "%s", "allocator incompatible for merge")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"allocator incompatible for merge\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1446, 0); } while (false); } ; } while (false);
        }
#line 1449 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

            _List._Mypair._Myval2._Adopt_unique(_That._List._Mypair._Myval2, _Candidate);
#line 1481 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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)};
            }
        }


        do { if (_List.get_allocator() == _Handle._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1535, 0, "%s", "node handle allocator incompatible for insert")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"node handle allocator incompatible for insert\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash", 1535, 0); } while (false); } ; } while (false);
#line 1537 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1564 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2009 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2038 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"
#line 2039 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xhash"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"



#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

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 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }





















































#line 248 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"

    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 524 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"
#line 525 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 539 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 553 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
#line 562 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

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);
    }






















































#line 735 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"

    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 895 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"
#line 896 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 910 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 924 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"






#line 931 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 942 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"
}


#pragma warning(pop)
#pragma pack(pop)
#line 948 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"
#line 949 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_map"
#pragma external_header(pop)
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"
#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"


#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Ty = void>
struct divides {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left / _Right;
    }
};

 template <class _Ty = void>
struct modulus {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left % _Right;
    }
};

 template <class _Ty = void>
struct negate {
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left) const {
        return -_Left;
    }
};




 template <class _Ty = void>
struct logical_and {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left && _Right;
    }
};

 template <class _Ty = void>
struct logical_or {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left || _Right;
    }
};

 template <class _Ty = void>
struct logical_not {
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = bool;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left) const {
        return !_Left;
    }
};

 template <class _Ty = void>
struct bit_and {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left & _Right;
    }
};

 template <class _Ty = void>
struct bit_or {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left | _Right;
    }
};

 template <class _Ty = void>
struct bit_xor {
    using _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 suppress this warning.")]]  = _Ty;
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = _Ty;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left ^ _Right;
    }
};

 template <class _Ty = void>
struct bit_not {
    using _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 suppress this warning.")]] = _Ty;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = _Ty;

    [[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 302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"







































































































































































































































































#line 566 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 643 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"

 class bad_function_call : public exception { 
public:
    bad_function_call() noexcept {}

    [[nodiscard]] const char*  what() const noexcept override {
        
        return "bad function call";
    }
};

extern "C++" [[noreturn]]  void __cdecl _Xbad_function_call();

 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 686 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
};

inline 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 775 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 { 
        if constexpr (is_void_v<_Rx>) {
            (void) ::std:: invoke(_Callee, ::std:: forward<_Types>(_Args)...);
        } else {
            return ::std:: invoke(_Callee, ::std:: forward<_Types>(_Args)...);
        }
    }

    const type_info& _Target_type() const noexcept override {

        return typeid(_Callable);


#line 819 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
};

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 926 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 956 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 __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 __vectorcall(_Types...) noexcept> { static_assert( _Always_false<_Ret>, "std::function does not accept noexcept function types as template arguments."); };

#line 1003 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    function(_Fx&& _Func) {
        this->_Reset(::std:: forward<_Fx>(_Func));
    }

















#line 1040 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"

    function& operator=(const function& _Right) {
        function(_Right).swap(*this);
        return *this;
    }

    function(function&& _Right) noexcept {
        this->_Reset_move(::std:: move(_Right));
    }






#line 1056 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    function& operator=(_Fx&& _Func) {
        function(::std:: forward<_Fx>(_Func)).swap(*this);
        return *this;
    }






#line 1077 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
        if constexpr (is_function_v<_Fx>) {
            return nullptr;
        } else {
            return reinterpret_cast<_Fx*>(const_cast<void*>(this->_Target(typeid(_Fx))));
        }
    }

    template <class _Fx>
    [[nodiscard]] const _Fx* target() const noexcept {
        if constexpr (is_function_v<_Fx>) {
            return nullptr;
        } else {
            return reinterpret_cast<const _Fx*>(this->_Target(typeid(_Fx)));
        }
    }








#line 1129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"
};






template <class _Ret, class... _Types> function(_Ret(__cdecl*)(_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 1149 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1176 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"










































































































































































































































































































































































































































































































































































































































































































#line 1859 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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,
        enable_if_t<conjunction_v<bool_constant<(_Jx < tuple_size_v<_Untuple>)>...>, int> = 0>
    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, enable_if_t<(_Jx <= tuple_size_v<_Untuple>), int> = 0>
    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));
}

struct _Unforced { 
    explicit _Unforced() = default;
};


template <class _Rx>
struct _Invoker_ret { 
    template <class _Fx, class... _Valtys,
        enable_if_t<_Select_invoke_traits<_Fx, _Valtys...>::template _Is_invocable_r<_Rx>::value, int> = 0>
    static constexpr _Rx _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(_Select_invoke_traits<_Fx,
        _Valtys...>::template _Is_nothrow_invocable_r<_Rx>::value) { 
        if constexpr (is_void_v<_Rx>) {
            ;
#line 1978 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"
            ::std:: invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
        } else {
            return ::std:: invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
        }
    }
};

template <>
struct _Invoker_ret<_Unforced> { 
    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 _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,
    ::std:: _Fix_arg(::std:: get<_Ix>(_Tpl), ::std:: move(_Ut))...)))
    -> decltype(_Invoker_ret<_Ret>::_Call(_Obj, ::std:: _Fix_arg(::std:: get<_Ix>(_Tpl), ::std:: move(_Ut))...)) {
    
    return _Invoker_ret<_Ret>::_Call(_Obj, ::std:: _Fix_arg(::std:: get<_Ix>(_Tpl), ::std:: move(_Ut))...);
}


template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple>
concept _Can_call_binder = requires(_CvFD& _Fx, _CvBoundTuple& _Bound_tuple, _UnboundTuple&& _Unbound_tuple) {
    ::std:: _Call_binder(_Invoker_ret<_Ret>{}, _IntSeq{}, _Fx, _Bound_tuple, ::std:: move(_Unbound_tuple));
};








#line 2018 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"

template <class _Ret>
struct _Forced_result_type { 
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]] = _Ret;
};

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 _Fd          = decay_t<_Fx>;
    using _Bound_tuple = tuple<decay_t<_Types>...>;

    _Compressed_pair<_Fd, _Bound_tuple> _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>
        requires _Can_call_binder<_Ret, _Fd, _Seq, _Bound_tuple, tuple<_Unbound&&...>>
    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) noexcept(noexcept(::std:: _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...)))) {
        return ::std:: _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...));
    }

    template <class... _Unbound>
    void operator()(_Unbound&&...) = delete;

    template <class... _Unbound>
        requires _Can_call_binder<_Ret, const _Fd, _Seq, const _Bound_tuple, tuple<_Unbound&&...>>
    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const noexcept(noexcept(::std:: _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...)))) {
        return ::std:: _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...));
    }

    template <class... _Unbound>
    void operator()(_Unbound&&...) const = delete;




















#line 2090 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"

};

 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 _IntSeq, class _CvFD, class _CvBoundTuple, class... _Unbound>
concept _Can_call_front_binder = requires(_CvFD&& _Fx, _CvBoundTuple&& _Bound_tuple, _Unbound&&... _Unbound_args) {
    ::std:: _Call_front_binder(_IntSeq{}, ::std:: forward<_CvFD>(_Fx), ::std:: forward<_CvBoundTuple>(_Bound_tuple),
        ::std:: forward<_Unbound>(_Unbound_args)...);
};













#line 2157 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"

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>
        requires _Can_call_front_binder<_Seq, _Fx&, tuple<_Types...>&, _Unbound...>
    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) & noexcept(noexcept(
        ::std:: _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...))) {
        return ::std:: _Call_front_binder(
            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    void operator()(_Unbound&&...) & = delete;

    template <class... _Unbound>
        requires _Can_call_front_binder<_Seq, const _Fx&, const tuple<_Types...>&, _Unbound...>
    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const& noexcept(noexcept(
        ::std:: _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...))) {
        return ::std:: _Call_front_binder(
            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    void operator()(_Unbound&&...) const& = delete;

    template <class... _Unbound>
        requires _Can_call_front_binder<_Seq, _Fx, tuple<_Types...>, _Unbound...>
    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) && noexcept(noexcept(::std:: _Call_front_binder(
        _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...))) {
        return ::std:: _Call_front_binder(
            _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    void operator()(_Unbound&&...) && = delete;

    template <class... _Unbound>
        requires _Can_call_front_binder<_Seq, const _Fx, const tuple<_Types...>, _Unbound...>
    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const&& noexcept(noexcept(::std:: _Call_front_binder(
        _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...))) {
        return ::std:: _Call_front_binder(
            _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    void operator()(_Unbound&&...) const&& = delete;















































#line 2266 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"
};

 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 2282 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"



























































































































































#line 2438 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"




#line 2443 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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)));
}

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) {
    
    if constexpr (_Is_ranges_random_iter_v<_FwdItHaystack> && _Is_ranges_random_iter_v<_FwdItPat>) {
        _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};
    } else {
        static_assert(_Is_ranges_fwd_iter_v<_FwdItHaystack> && _Is_ranges_fwd_iter_v<_FwdItPat>,
            "Iterators must be at least forward iterators");
        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 _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);
        _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];
};



enum class _Deletion_kind { _Global_scalar, _Normal_array };

template <class _Ty, _Deletion_kind _Del>
class _Mini_ptr {
public:
    explicit _Mini_ptr(_Ty* const _Ptr_) noexcept : _Ptr(_Ptr_) {}

    ~_Mini_ptr() noexcept {
        if (_Ptr) {
            if constexpr (_Del == _Deletion_kind::_Global_scalar) {
                ::operator delete(_Ptr);
            } else if constexpr (_Del == _Deletion_kind::_Normal_array) {
                delete[] _Ptr;
            } else {
                static_assert(_Always_false<_Ty>, "Unknown _Deletion_kind.");
            }
        }
    }

    [[nodiscard]] _Ty* _Get() const noexcept {
        return _Ptr;
    }

    [[nodiscard]] _Ty* _Release() noexcept {
        return ::std:: exchange(_Ptr, nullptr);
    }

    _Mini_ptr(const _Mini_ptr&)            = delete;
    _Mini_ptr& operator=(const _Mini_ptr&) = delete;

private:
    _Ty* _Ptr;
};

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 _Mini_ptr<size_t, _Deletion_kind::_Normal_array> _Fx_ptr{new size_t[_Mx]};
    size_t* const _Fx = _Fx_ptr._Get();

    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>(0xffffffffffffffffui64)) {
            _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);
        }

        _Mini_ptr<void, _Deletion_kind::_Global_scalar> _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>(0xffffffffffffffffui64)) {
            _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);
        }

        _Mini_ptr<void, _Deletion_kind::_Global_scalar> _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 3083 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3120 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"














#line 3135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"

}



#pragma warning(pop)
#pragma pack(pop)
#line 3143 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"
#line 3144 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\functional"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"



#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"


#pragma warning( push )
#pragma warning( disable : 4311 ) 
#pragma warning( disable : 4127 ) 
#line 59 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"



class QBitArray;
class QByteArray;
class QString;
class QStringRef;
class QLatin1String;

__declspec(dllimport) int qGlobalQHashSeed();
__declspec(dllimport) void qSetGlobalQHashSeed(int newSeed);

__declspec(dllimport)  uint qHashBits(const void *p, size_t size, uint seed = 0) noexcept;

 constexpr inline uint qHash(char key, uint seed = 0) noexcept { return uint(key) ^ seed; }
 constexpr inline uint qHash(uchar key, uint seed = 0) noexcept { return uint(key) ^ seed; }
 constexpr inline uint qHash(signed char key, uint seed = 0) noexcept { return uint(key) ^ seed; }
 constexpr inline uint qHash(ushort key, uint seed = 0) noexcept { return uint(key) ^ seed; }
 constexpr inline uint qHash(short key, uint seed = 0) noexcept { return uint(key) ^ seed; }
 constexpr inline uint qHash(uint key, uint seed = 0) noexcept { return key ^ seed; }
 constexpr inline uint qHash(int key, uint seed = 0) noexcept { return uint(key) ^ seed; }
 constexpr inline uint qHash(ulong key, uint seed = 0) noexcept
{
    return (sizeof(ulong) > sizeof(uint))
        ? (uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed)
        : (uint(key & (~0U)) ^ seed);
}
 constexpr inline uint qHash(long key, uint seed = 0) noexcept { return qHash(ulong(key), seed); }
 constexpr inline uint qHash(quint64 key, uint seed = 0) noexcept
{
    return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed;
}
 constexpr inline uint qHash(qint64 key, uint seed = 0) noexcept { return qHash(quint64(key), seed); }
__declspec(dllimport)  uint qHash(float key, uint seed = 0) noexcept;
__declspec(dllimport)  uint qHash(double key, uint seed = 0) noexcept;

__declspec(dllimport)  uint qHash(long double key, uint seed = 0) noexcept;
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"
 constexpr inline uint qHash(const QChar key, uint seed = 0) noexcept { return qHash(key.unicode(), seed); }
__declspec(dllimport)  uint qHash(const QByteArray &key, uint seed = 0) noexcept;

__declspec(dllimport)  uint qHash(const QString &key, uint seed = 0) noexcept;
__declspec(dllimport)  uint qHash(const QStringRef &key, uint seed = 0) noexcept;
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"
__declspec(dllimport)  uint qHash(QStringView key, uint seed = 0) noexcept;
__declspec(dllimport)  uint qHash(const QBitArray &key, uint seed = 0) noexcept;
__declspec(dllimport)  uint qHash(QLatin1String key, uint seed = 0) noexcept;
__declspec(dllimport)  uint qt_hash(QStringView key, uint chained = 0) noexcept;

 inline uint qHash(std::nullptr_t, uint seed = 0) noexcept
{
    return qHash(reinterpret_cast<quintptr>(nullptr), seed);
}

template <class T> inline uint qHash(const T *key, uint seed = 0) noexcept
{
    return qHash(reinterpret_cast<quintptr>(key), seed);
}
template<typename T> inline uint qHash(const T &t, uint seed)
    noexcept(noexcept(qHash(t)))
{ return qHash(t) ^ seed; }

namespace QtPrivate {

struct QHashCombine {
    typedef uint result_type;
    template <typename T>
    constexpr result_type operator()(uint seed, const T &t) const noexcept(noexcept(qHash(t)))
    
    { return seed ^ (qHash(t) + 0x9e3779b9 + (seed << 6) + (seed >> 2)) ; }
};

struct QHashCombineCommutative {
    
    
    
    
    
    typedef uint result_type;
    template <typename T>
    constexpr result_type operator()(uint seed, const T &t) const noexcept(noexcept(qHash(t)))
    { return seed + qHash(t); } 
};

} 

template <typename InputIterator>
inline uint qHashRange(InputIterator first, InputIterator last, uint seed = 0)
    noexcept(noexcept(qHash(*first))) 
{
    return std::accumulate(first, last, seed, QtPrivate::QHashCombine());
}

template <typename InputIterator>
inline uint qHashRangeCommutative(InputIterator first, InputIterator last, uint seed = 0)
    noexcept(noexcept(qHash(*first))) 
{
    return std::accumulate(first, last, seed, QtPrivate::QHashCombineCommutative());
}

template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key, uint seed = 0)
    noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed)))
{
    uint h1 = qHash(key.first, seed);
    uint h2 = qHash(key.second, seed);
    return ((h1 << 16) | (h1 >> 16)) ^ h2 ^ seed;
}

template <typename T1, typename T2> inline uint qHash(const std::pair<T1, T2> &key, uint seed = 0)
    noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed)))
{
    QtPrivate::QHashCombine hash;
    seed = hash(seed, key.first);
    seed = hash(seed, key.second);
    return seed;
}





























 namespace std { template <> struct hash< ::QString > { using argument_type = ::QString; using result_type = size_t; size_t operator()(const argument_type & s) const noexcept(noexcept(::qHash(s))) { return ::qHash(s, ::qHash( std::hash<int>{}(0))); } }; } 
 namespace std { template <> struct hash< ::QStringRef > { using argument_type = ::QStringRef; using result_type = size_t; size_t operator()(const argument_type & s) const noexcept(noexcept(::qHash(s))) { return ::qHash(s, ::qHash( std::hash<int>{}(0))); } }; } 
 namespace std { template <> struct hash< ::QStringView > { using argument_type = ::QStringView; using result_type = size_t; size_t operator()(argument_type s) const noexcept(noexcept(::qHash(s))) { return ::qHash(s, ::qHash( std::hash<int>{}(0))); } }; } 
 namespace std { template <> struct hash< ::QLatin1String > { using argument_type = ::QLatin1String; using result_type = size_t; size_t operator()(argument_type s) const noexcept(noexcept(::qHash(s))) { return ::qHash(s, ::qHash( std::hash<int>{}(0))); } }; } 
 namespace std { template <> struct hash< ::QByteArray > { using argument_type = ::QByteArray; using result_type = size_t; size_t operator()(const argument_type & s) const noexcept(noexcept(::qHash(s))) { return ::qHash(s, ::qHash( std::hash<int>{}(0))); } }; } 
 namespace std { template <> struct hash< ::QBitArray > { using argument_type = ::QBitArray; using result_type = size_t; size_t operator()(const argument_type & s) const noexcept(noexcept(::qHash(s))) { return ::qHash(s, ::qHash( std::hash<int>{}(0))); } }; } 




#pragma warning( pop )
#line 216 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"

#line 218 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhashfunctions.h"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"




template <class T> class QSharedDataPointer;

class

__declspec(dllimport)
#line 59 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"
QSharedData
{
public:
    mutable QAtomicInt ref;

    inline QSharedData() noexcept : ref(0) { }
    inline QSharedData(const QSharedData &) noexcept : ref(0) { }

    
    QSharedData &operator=(const QSharedData &) = delete;
    ~QSharedData() = default;
};

template <class T> class QSharedDataPointer
{
public:
    typedef T Type;
    typedef T *pointer;

    inline void detach() { if (d && d->ref.loadRelaxed() != 1) detach_helper(); }
    inline T &operator*() { detach(); return *d; }
    inline const T &operator*() const { return *d; }
    inline T *operator->() { detach(); return d; }
    inline const T *operator->() const { return d; }
    inline operator T *() { detach(); return d; }
    inline operator const T *() const { return d; }
    inline T *data() { detach(); return d; }
    inline const T *data() const { return d; }
    inline const T *constData() const { return d; }

    inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; }
    inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; }

    inline QSharedDataPointer() { d = nullptr; }
    inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }

    explicit QSharedDataPointer(T *data) noexcept;
    inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
    inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) {
        if (o.d != d) {
            if (o.d)
                o.d->ref.ref();
            T *old = d;
            d = o.d;
            if (old && !old->ref.deref())
                delete old;
        }
        return *this;
    }
    inline QSharedDataPointer &operator=(T *o) {
        if (o != d) {
            if (o)
                o->ref.ref();
            T *old = d;
            d = o;
            if (old && !old->ref.deref())
                delete old;
        }
        return *this;
    }
    QSharedDataPointer(QSharedDataPointer &&o) noexcept : d(o.d) { o.d = nullptr; }
    inline QSharedDataPointer<T> &operator=(QSharedDataPointer<T> &&other) noexcept
    {
        QSharedDataPointer moved(std::move(other));
        swap(moved);
        return *this;
    }

    inline bool operator!() const { return !d; }

    inline void swap(QSharedDataPointer &other) noexcept
    { qSwap(d, other.d); }

protected:
    T *clone();

private:
    void detach_helper();

    T *d;
};

template <class T> inline bool operator==(std::nullptr_t p1, const QSharedDataPointer<T> &p2)
{
    (void)p1;;
    return !p2;
}

template <class T> inline bool operator==(const QSharedDataPointer<T> &p1, std::nullptr_t p2)
{
    (void)p2;;
    return !p1;
}

template <class T> class QExplicitlySharedDataPointer
{
public:
    typedef T Type;
    typedef T *pointer;

    inline T &operator*() const { return *d; }
    inline T *operator->() { return d; }
    inline T *operator->() const { return d; }
    inline T *data() const { return d; }
    inline const T *constData() const { return d; }
    inline T *take() { T *x = d; d = nullptr; return x; }

    inline void detach() { if (d && d->ref.loadRelaxed() != 1) detach_helper(); }

    inline void reset()
    {
        if(d && !d->ref.deref())
            delete d;

        d = nullptr;
    }

    inline operator bool () const { return d != nullptr; }

    inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; }
    inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; }
    inline bool operator==(const T *ptr) const { return d == ptr; }
    inline bool operator!=(const T *ptr) const { return d != ptr; }

    inline QExplicitlySharedDataPointer() { d = nullptr; }
    inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }

    explicit QExplicitlySharedDataPointer(T *data) noexcept;
    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }

    template<class X>
    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)



        : d(o.data())
#line 196 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"
    {
        if(d)
            d->ref.ref();
    }

    inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) {
        if (o.d != d) {
            if (o.d)
                o.d->ref.ref();
            T *old = d;
            d = o.d;
            if (old && !old->ref.deref())
                delete old;
        }
        return *this;
    }
    inline QExplicitlySharedDataPointer &operator=(T *o) {
        if (o != d) {
            if (o)
                o->ref.ref();
            T *old = d;
            d = o;
            if (old && !old->ref.deref())
                delete old;
        }
        return *this;
    }
    inline QExplicitlySharedDataPointer(QExplicitlySharedDataPointer &&o) noexcept : d(o.d) { o.d = nullptr; }
    inline QExplicitlySharedDataPointer<T> &operator=(QExplicitlySharedDataPointer<T> &&other) noexcept
    {
        QExplicitlySharedDataPointer moved(std::move(other));
        swap(moved);
        return *this;
    }

    inline bool operator!() const { return !d; }

    inline void swap(QExplicitlySharedDataPointer &other) noexcept
    { qSwap(d, other.d); }

protected:
    T *clone();

private:
    void detach_helper();

    T *d;
};

template <class T>
inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) noexcept
    : d(adata)
{ if (d) d->ref.ref(); }

template <class T>
inline T *QSharedDataPointer<T>::clone()
{
    return new T(*d);
}

template <class T>
inline void QSharedDataPointer<T>::detach_helper()
{
    T *x = clone();
    x->ref.ref();
    if (!d->ref.deref())
        delete d;
    d = x;
}

template <class T>
inline T *QExplicitlySharedDataPointer<T>::clone()
{
    return new T(*d);
}

template <class T>
inline void QExplicitlySharedDataPointer<T>::detach_helper()
{
    T *x = clone();
    x->ref.ref();
    if (!d->ref.deref())
        delete d;
    d = x;
}

template <class T>
inline QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) noexcept
    : d(adata)
{ if (d) d->ref.ref(); }

template <class T> inline bool operator==(std::nullptr_t p1, const QExplicitlySharedDataPointer<T> &p2)
{
    (void)p1;;
    return !p2;
}

template <class T> inline bool operator==(const QExplicitlySharedDataPointer<T> &p1, std::nullptr_t p2)
{
    (void)p2;;
    return !p1;
}

template <class T>
inline void swap(QSharedDataPointer<T> &p1, QSharedDataPointer<T> &p2)
{ p1.swap(p2); }

template <class T>
inline void swap(QExplicitlySharedDataPointer<T> &p1, QExplicitlySharedDataPointer<T> &p2)
{ p1.swap(p2); }

template <class T>
inline uint qHash(const QSharedDataPointer<T> &ptr, uint seed = 0) noexcept
{
    return qHash(ptr.data(), seed);
}
template <class T>
inline uint qHash(const QExplicitlySharedDataPointer<T> &ptr, uint seed = 0) noexcept
{
    return qHash(ptr.data(), seed);
}

template<typename T> class QTypeInfo<QSharedDataPointer<T> > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QSharedDataPointer<T>>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QSharedDataPointer<T>>(), isLarge = (sizeof(QSharedDataPointer<T>)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QSharedDataPointer<T> >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QSharedDataPointer<T>) }; static inline const char *name() { return "QSharedDataPointer<T>"; } };
template<typename T> class QTypeInfo<QExplicitlySharedDataPointer<T> > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QExplicitlySharedDataPointer<T>>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QExplicitlySharedDataPointer<T>>(), isLarge = (sizeof(QExplicitlySharedDataPointer<T>)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QExplicitlySharedDataPointer<T> >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QExplicitlySharedDataPointer<T>) }; static inline const char *name() { return "QExplicitlySharedDataPointer<T>"; } };



#line 324 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qshareddata.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"






#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"



class QCalendar;

class QTimeZone;
#line 61 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
class QDateTime;

class __declspec(dllimport) QDate 
{
public:
    enum MonthNameType { 
        DateFormat = 0,
        StandaloneFormat
    };
private:
    explicit constexpr QDate(qint64 julianDay) : jd(julianDay) {}
public:
    constexpr QDate() : jd(nullJd()) {}
    QDate(int y, int m, int d);
    QDate(int y, int m, int d, QCalendar cal);

    constexpr bool isNull() const { return !isValid(); }
    constexpr bool isValid() const { return jd >= minJd() && jd <= maxJd(); }

    int year() const;
    int month() const;
    int day() const;
    int dayOfWeek() const;
    int dayOfYear() const;
    int daysInMonth() const;
    int daysInYear() const;
    int weekNumber(int *yearNum = nullptr) const;

    int year(QCalendar cal) const;
    int month(QCalendar cal) const;
    int day(QCalendar cal) const;
    int dayOfWeek(QCalendar cal) const;
    int dayOfYear(QCalendar cal) const;
    int daysInMonth(QCalendar cal) const;
    int daysInYear(QCalendar cal) const;

    QDateTime startOfDay(Qt::TimeSpec spec = Qt::LocalTime, int offsetSeconds = 0) const;
    QDateTime endOfDay(Qt::TimeSpec spec = Qt::LocalTime, int offsetSeconds = 0) const;

    QDateTime startOfDay(const QTimeZone &zone) const;
    QDateTime endOfDay(const QTimeZone &zone) const;
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"










#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    QString toString(Qt::DateFormat format = Qt::TextDate) const;




#line 121 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"


    QString toString(const QString &format) const;
    QString toString(const QString &format, QCalendar cal) const;
#line 126 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    QString toString(QStringView format) const;
    QString toString(QStringView format, QCalendar cal) const;
#line 130 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"



#line 134 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    bool setDate(int year, int month, int day);
    bool setDate(int year, int month, int day, QCalendar cal);


    void getDate(int *year, int *month, int *day); 
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    void getDate(int *year, int *month, int *day) const;

    [[nodiscard]] QDate addDays(qint64 days) const;
    [[nodiscard]] QDate addMonths(int months) const;
    [[nodiscard]] QDate addYears(int years) const;
    [[nodiscard]] QDate addMonths(int months, QCalendar cal) const;
    [[nodiscard]] QDate addYears(int years, QCalendar cal) const;
    qint64 daysTo(const QDate &) const; 

    constexpr bool operator==(const QDate &other) const { return jd == other.jd; }
    constexpr bool operator!=(const QDate &other) const { return jd != other.jd; }
    constexpr bool operator< (const QDate &other) const { return jd <  other.jd; }
    constexpr bool operator<=(const QDate &other) const { return jd <= other.jd; }
    constexpr bool operator> (const QDate &other) const { return jd >  other.jd; }
    constexpr bool operator>=(const QDate &other) const { return jd >= other.jd; }

    static QDate currentDate();

    static QDate fromString(const QString &s, Qt::DateFormat f = Qt::TextDate);
    static QDate fromString(const QString &s, const QString &format);
    static QDate fromString(const QString &s, const QString &format, QCalendar cal);
#line 163 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    static bool isValid(int y, int m, int d);
    static bool isLeapYear(int year);

    static constexpr inline QDate fromJulianDay(qint64 jd_)
    { return jd_ >= minJd() && jd_ <= maxJd() ? QDate(jd_) : QDate() ; }
    constexpr inline qint64 toJulianDay() const { return jd; }

private:
    
    static constexpr inline qint64 nullJd() { return (std::numeric_limits<qint64>::min)(); }
    static constexpr inline qint64 minJd() { return -784350574879i64; }
    static constexpr inline qint64 maxJd() { return 784354017364i64; }

    qint64 jd;

    friend class QDateTime;
    friend class QDateTimePrivate;

    friend __declspec(dllimport) QDataStream &operator<<(QDataStream &, const QDate &);
    friend __declspec(dllimport) QDataStream &operator>>(QDataStream &, QDate &);
#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
};
template<> class QTypeInfo<QDate > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QDate>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QDate>(), isLarge = (sizeof(QDate)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QDate >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QDate) }; static inline const char *name() { return "QDate"; } };

class __declspec(dllimport) QTime 
{
    explicit constexpr QTime(int ms) : mds(ms)
    {}
public:
    constexpr QTime(): mds(NullTime)
    {}
    QTime(int h, int m, int s = 0, int ms = 0);

    constexpr bool isNull() const { return mds == NullTime; }
    bool isValid() const;

    int hour() const;
    int minute() const;
    int second() const;
    int msec() const;

    QString toString(Qt::DateFormat f = Qt::TextDate) const;

    QString toString(const QString &format) const;
#line 208 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    QString toString(QStringView format) const;
#line 210 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    bool setHMS(int h, int m, int s, int ms = 0);

    [[nodiscard]] QTime addSecs(int secs) const;
    int secsTo(const QTime &) const; 
    [[nodiscard]] QTime addMSecs(int ms) const;
    int msecsTo(const QTime &) const; 

    constexpr bool operator==(const QTime &other) const { return mds == other.mds; }
    constexpr bool operator!=(const QTime &other) const { return mds != other.mds; }
    constexpr bool operator< (const QTime &other) const { return mds <  other.mds; }
    constexpr bool operator<=(const QTime &other) const { return mds <= other.mds; }
    constexpr bool operator> (const QTime &other) const { return mds >  other.mds; }
    constexpr bool operator>=(const QTime &other) const { return mds >= other.mds; }

    static constexpr inline QTime fromMSecsSinceStartOfDay(int msecs) { return QTime(msecs); }
    constexpr inline int msecsSinceStartOfDay() const { return mds == NullTime ? 0 : mds; }

    static QTime currentTime();

    static QTime fromString(const QString &s, Qt::DateFormat f = Qt::TextDate);
    static QTime fromString(const QString &s, const QString &format);
#line 232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    static bool isValid(int h, int m, int s, int ms = 0);





#line 239 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
private:
    enum TimeFlag { NullTime = -1 };
    constexpr inline int ds() const { return mds == -1 ? 0 : mds; }
    int mds;

    friend class QDateTime;
    friend class QDateTimePrivate;

    friend __declspec(dllimport) QDataStream &operator<<(QDataStream &, const QTime &);
    friend __declspec(dllimport) QDataStream &operator>>(QDataStream &, QTime &);
#line 250 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
};
template<> class QTypeInfo<QTime > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QTime>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QTime>(), isLarge = (sizeof(QTime)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QTime >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QTime) }; static inline const char *name() { return "QTime"; } };

class QDateTimePrivate;

class __declspec(dllimport) QDateTime
{
    
    struct ShortData {

        quintptr status : 8;
#line 262 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
        
        qintptr msecs : sizeof(void *) * 8 - 8;



#line 268 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    };

    union Data {
        enum {
            
            
            
            CanBeSmall = sizeof(ShortData) * 8 > 50
        };

        Data();
        Data(Qt::TimeSpec);
        Data(const Data &other);
        Data(Data &&other);
        Data &operator=(const Data &other);
        ~Data();

        bool isShort() const;
        void detach();

        const QDateTimePrivate *operator->() const;
        QDateTimePrivate *operator->();

        QDateTimePrivate *d;
        ShortData data;
    };

public:
    QDateTime() noexcept(Data::CanBeSmall);


#line 300 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    QDateTime(const QDate &, const QTime &, Qt::TimeSpec spec = Qt::LocalTime);
    
    QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec, int offsetSeconds);

    QDateTime(const QDate &date, const QTime &time, const QTimeZone &timeZone);
#line 306 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    QDateTime(const QDateTime &other) noexcept;
    QDateTime(QDateTime &&other) noexcept;
    ~QDateTime();

    QDateTime &operator=(QDateTime &&other) noexcept { swap(other); return *this; }
    QDateTime &operator=(const QDateTime &other) noexcept;

    void swap(QDateTime &other) noexcept { qSwap(d.d, other.d.d); }

    bool isNull() const;
    bool isValid() const;

    QDate date() const;
    QTime time() const;
    Qt::TimeSpec timeSpec() const;
    int offsetFromUtc() const;

    QTimeZone timeZone() const;
#line 325 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    QString timeZoneAbbreviation() const;
    bool isDaylightTime() const;

    qint64 toMSecsSinceEpoch() const;
    qint64 toSecsSinceEpoch() const;

    void setDate(const QDate &date); 
    void setTime(const QTime &time);
    void setTimeSpec(Qt::TimeSpec spec);
    void setOffsetFromUtc(int offsetSeconds);

    void setTimeZone(const QTimeZone &toZone);
#line 338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    void setMSecsSinceEpoch(qint64 msecs);
    void setSecsSinceEpoch(qint64 secs);


    QString toString(Qt::DateFormat format = Qt::TextDate) const;

    QString toString(const QString &format) const;
    QString toString(const QString &format, QCalendar cal) const;
#line 347 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    QString toString(QStringView format) const;
    QString toString(QStringView format, QCalendar cal) const;
#line 350 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
    [[nodiscard]] QDateTime addDays(qint64 days) const;
    [[nodiscard]] QDateTime addMonths(int months) const;
    [[nodiscard]] QDateTime addYears(int years) const;
    [[nodiscard]] QDateTime addSecs(qint64 secs) const;
    [[nodiscard]] QDateTime addMSecs(qint64 msecs) const;

    QDateTime toTimeSpec(Qt::TimeSpec spec) const;
    inline QDateTime toLocalTime() const { return toTimeSpec(Qt::LocalTime); }
    inline QDateTime toUTC() const { return toTimeSpec(Qt::UTC); }
    QDateTime toOffsetFromUtc(int offsetSeconds) const;

    QDateTime toTimeZone(const QTimeZone &toZone) const;
#line 363 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    qint64 daysTo(const QDateTime &) const;
    qint64 secsTo(const QDateTime &) const;
    qint64 msecsTo(const QDateTime &) const;

    bool operator==(const QDateTime &other) const;
    inline bool operator!=(const QDateTime &other) const { return !(*this == other); }
    bool operator<(const QDateTime &other) const;
    inline bool operator<=(const QDateTime &other) const { return !(other < *this); }
    inline bool operator>(const QDateTime &other) const { return other < *this; }
    inline bool operator>=(const QDateTime &other) const { return !(*this < other); }




#line 379 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    static QDateTime currentDateTime();
    static QDateTime currentDateTimeUtc();

    static QDateTime fromString(const QString &s, Qt::DateFormat f = Qt::TextDate);
    static QDateTime fromString(const QString &s, const QString &format);
    static QDateTime fromString(const QString &s, const QString &format, QCalendar cal);
#line 387 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"










#line 398 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    static QDateTime fromMSecsSinceEpoch(qint64 msecs);
    
    static QDateTime fromMSecsSinceEpoch(qint64 msecs, Qt::TimeSpec spec, int offsetFromUtc = 0);
    static QDateTime fromSecsSinceEpoch(qint64 secs, Qt::TimeSpec spe = Qt::LocalTime, int offsetFromUtc = 0);


    static QDateTime fromMSecsSinceEpoch(qint64 msecs, const QTimeZone &timeZone);
    static QDateTime fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone);
#line 408 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    static qint64 currentMSecsSinceEpoch() noexcept;
    static qint64 currentSecsSinceEpoch() noexcept;






#line 418 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"

    
    
    enum class YearRange : qint32 { First = -292275056,  Last = +292278994 };

private:
    friend class QDateTimePrivate;

    Data d;


    friend __declspec(dllimport) QDataStream &operator<<(QDataStream &, const QDateTime &);
    friend __declspec(dllimport) QDataStream &operator>>(QDataStream &, QDateTime &);
#line 432 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"


    friend __declspec(dllimport) QDebug operator<<(QDebug, const QDateTime &);
#line 436 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
};
template<> class QTypeInfo<QDateTime > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QDateTime>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QDateTime>(), isLarge = (sizeof(QDateTime)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QDateTime >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QDateTime) }; static inline const char *name() { return "QDateTime"; } }; inline void swap(QDateTime &value1, QDateTime &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }


__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QDate &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QDate &);
__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QTime &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QTime &);
__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QDateTime &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QDateTime &);
#line 447 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"


__declspec(dllimport) QDebug operator<<(QDebug, const QDate &);
__declspec(dllimport) QDebug operator<<(QDebug, const QTime &);
__declspec(dllimport) QDebug operator<<(QDebug, const QDateTime &);
#line 453 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"



__declspec(dllimport) uint qHash(const QDateTime &key, uint seed = 0);
__declspec(dllimport) uint qHash(const QDate &key, uint seed = 0) noexcept;
__declspec(dllimport) uint qHash(const QTime &key, uint seed = 0) noexcept;



#line 463 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdatetime.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QDateTime"
#pragma external_header(pop)
#line 8 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QDebug"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"













































#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"












#pragma once








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


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\setjmp.h"







#pragma once












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

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
























#line 50 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\setjmp.h"

    typedef struct __declspec(align(16)) _SETJMP_FLOAT128
    {
        unsigned __int64 Part[2];
    } SETJMP_FLOAT128;

    
    typedef SETJMP_FLOAT128 _JBTYPE;

    typedef struct _JUMP_BUFFER
    {
        unsigned __int64 Frame;
        unsigned __int64 Rbx;
        unsigned __int64 Rsp;
        unsigned __int64 Rbp;
        unsigned __int64 Rsi;
        unsigned __int64 Rdi;
        unsigned __int64 R12;
        unsigned __int64 R13;
        unsigned __int64 R14;
        unsigned __int64 R15;
        unsigned __int64 Rip;
        unsigned long MxCsr;
        unsigned short FpCsr;
        unsigned short Spare;

        SETJMP_FLOAT128 Xmm6;
        SETJMP_FLOAT128 Xmm7;
        SETJMP_FLOAT128 Xmm8;
        SETJMP_FLOAT128 Xmm9;
        SETJMP_FLOAT128 Xmm10;
        SETJMP_FLOAT128 Xmm11;
        SETJMP_FLOAT128 Xmm12;
        SETJMP_FLOAT128 Xmm13;
        SETJMP_FLOAT128 Xmm14;
        SETJMP_FLOAT128 Xmm15;
    } _JUMP_BUFFER;






















































#line 142 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\setjmp.h"





    
    typedef _JBTYPE jmp_buf[16];
#line 150 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\setjmp.h"




    
#line 156 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\setjmp.h"




int __cdecl _setjmp(
      jmp_buf _Buf
    );


    __declspec(noreturn) void __cdecl longjmp(
          jmp_buf _Buf,
          int     _Value
        ) noexcept(false);





#line 175 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\setjmp.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 27 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"



#line 31 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"



    
        #pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"











#pragma once



#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"



#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"







#line 29 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"












#pragma once



#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"



#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"







#line 30 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"













#pragma once



#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"



#line 23 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"







#line 31 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"













#pragma once



#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"



#line 23 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"







#line 31 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"






#pragma once



#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"



#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"







#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"












#pragma once



#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"



#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"







#line 30 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"
















#pragma once



#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"



#line 26 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"







#line 34 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"























#pragma once



#line 29 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"



#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"







#line 41 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"





#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"










#pragma once






#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"



#line 23 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"



#line 27 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"


extern "C" { 


#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;









































































































































#line 184 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"


}; 
#line 188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"

#line 190 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"
#line 191 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"
#line 192 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mmintrin.h"
#pragma external_header(pop)
#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"
#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"
#line 82 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"

 
 
 
 
 
 
 
 
 
 




 
 
 
 
 
 
 
 
 
 

























#line 133 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"























































 
 
 


extern "C" { 
  
#line 196 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);








#line 287 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"





extern __int64 _mm_cvtss_si64(__m128 _A);
extern __int64 _mm_cvttss_si64(__m128 _A);
extern __m128  _mm_cvtsi64_ss(__m128 _A, __int64 _B);
#line 296 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);



















#line 331 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _m_prefetchit0(const void *);
extern void _m_prefetchit1(const void *);
#line 356 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"


#line 359 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 390 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"







 
 
 





















































































































#line 518 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"



}; 
#line 523 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"

#line 525 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"
#line 526 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"
#line 527 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xmmintrin.h"
#pragma external_header(pop)
#line 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 68 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);





#line 162 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


#line 222 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


#line 240 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


#line 248 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);







#line 346 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


#line 357 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


#line 365 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);



#line 392 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);






extern __int64 _mm_cvtsd_si64(__m128d);
extern __int64 _mm_cvttsd_si64(__m128d);
extern __m128d _mm_cvtsi64_sd(__m128d, __int64);
extern __m128i _mm_cvtsi64_si128(__int64);
extern __int64 _mm_cvtsi128_si64(__m128i);


#line 437 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"


}; 
#line 441 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"

#line 443 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"
#line 444 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"
#line 445 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\emmintrin.h"
#pragma external_header(pop)
#line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"

 
 
 














 
 
 


extern "C" { 
  
#line 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 103 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"

#line 105 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"
#line 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"
#line 107 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\pmmintrin.h"
#pragma external_header(pop)
#line 26 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"









extern "C" {
#line 37 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    
    
    
    
    

    extern __m128i _mm_hadd_epi16 (__m128i, __m128i);
    extern __m128i _mm_hadd_epi32 (__m128i, __m128i);
    extern __m128i _mm_hadds_epi16 (__m128i, __m128i);





#line 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    
    
    
    
    
    

    extern __m128i _mm_hsub_epi16 (__m128i, __m128i);
    extern __m128i _mm_hsub_epi32 (__m128i, __m128i);
    extern __m128i _mm_hsubs_epi16 (__m128i, __m128i);





#line 72 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    
    
    
    
    
    
    

    extern __m128i _mm_maddubs_epi16 (__m128i, __m128i);



#line 87 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    

    extern __m128i _mm_mulhrs_epi16 (__m128i, __m128i);



#line 96 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    

    extern __m128i _mm_shuffle_epi8 (__m128i, __m128i);



#line 105 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    

    extern __m128i _mm_sign_epi8 (__m128i, __m128i);
    extern __m128i _mm_sign_epi16 (__m128i, __m128i);
    extern __m128i _mm_sign_epi32 (__m128i, __m128i);





#line 118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    

    extern __m128i _mm_alignr_epi8 (__m128i, __m128i, int);



#line 127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

    
    

    extern __m128i _mm_abs_epi8 (__m128i);
    extern __m128i _mm_abs_epi16 (__m128i);
    extern __m128i _mm_abs_epi32 (__m128i);





#line 140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"


};
#line 144 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"

#line 146 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"
#line 147 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"
#line 148 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\tmmintrin.h"
#pragma external_header(pop)
#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"


















































extern "C" {
#line 85 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 );


        extern __m128i _mm_insert_epi64(__m128i , __int64 , const int );
#line 194 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"
        
        

        extern int   _mm_extract_epi8 (__m128i , const int );
        extern int   _mm_extract_epi32(__m128i , const int );


        extern __int64 _mm_extract_epi64(__m128i , const int );
#line 203 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"
        extern __m128i _mm_stream_load_si128(const __m128i*);
#line 258 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"


}; 
#line 262 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"

#line 264 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"
#line 265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"
#line 266 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\smmintrin.h"
#pragma external_header(pop)
#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"



extern "C" {
#line 38 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 );


    extern __int64 _mm_popcnt_u64(unsigned __int64 );
#line 121 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 );


    extern unsigned __int64 _mm_crc32_u64(unsigned __int64 , unsigned __int64 );
#line 133 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"


}; 
#line 137 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"

#line 139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"
#line 140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"
#line 141 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\nmmintrin.h"
#pragma external_header(pop)
#line 32 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"



extern "C" {
#line 37 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 88 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"

#line 90 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"
#line 91 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"
#line 92 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\wmmintrin.h"
#pragma external_header(pop)
#line 31 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"


extern "C" {
#line 35 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 616 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

extern void __cdecl _xsave64(void *, unsigned __int64);
#line 1264 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"






extern void __cdecl _xsaveopt(void *, unsigned __int64);

extern void __cdecl _xsaveopt64(void *, unsigned __int64);
#line 1274 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"





extern void __cdecl _xsavec(void *, unsigned __int64);

extern void __cdecl _xsavec64(void *, unsigned __int64);
#line 1283 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"






extern void __cdecl _xrstor(void const *, unsigned __int64);

extern void __cdecl _xrstor64(void const *, unsigned __int64);
#line 1293 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"






extern void __cdecl _xsaves(void *, unsigned __int64);

extern void __cdecl _xsaves64(void *, unsigned __int64);
#line 1303 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"






extern void __cdecl _xrstors(void const *, unsigned __int64);

extern void __cdecl _xrstors64(void const *, unsigned __int64);
#line 1313 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"





extern void __cdecl _fxsave(void *);

extern void __cdecl _fxsave64(void *);
#line 1322 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"





extern void __cdecl _fxrstor(void const *);

extern void __cdecl _fxrstor64(void const *);
#line 1331 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"







extern int __cdecl _rdrand16_step(unsigned short *);
extern int __cdecl _rdrand32_step(unsigned int *);

extern int __cdecl _rdrand64_step(unsigned __int64 *);
#line 1343 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"





extern unsigned int     __cdecl _readfsbase_u32(void);
extern unsigned int     __cdecl _readgsbase_u32(void);
extern unsigned __int64 __cdecl _readfsbase_u64(void);
extern unsigned __int64 __cdecl _readgsbase_u64(void);




extern void __cdecl _writefsbase_u32(unsigned int);
extern void __cdecl _writegsbase_u32(unsigned int);
extern void __cdecl _writefsbase_u64(unsigned __int64);
extern void __cdecl _writegsbase_u64(unsigned __int64);
#line 1361 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 );


extern unsigned __int64 _bextr_u64(unsigned __int64 ,
                                   unsigned int ,
                                   unsigned int );
extern unsigned __int64 _bextr2_u64(unsigned __int64 ,
                                    unsigned __int64 );
extern unsigned __int64 _blsi_u64(unsigned __int64);
extern unsigned __int64 _blsmsk_u64(unsigned __int64);
extern unsigned __int64 _blsr_u64(unsigned __int64);
extern unsigned __int64 _bzhi_u64(unsigned __int64 ,
                                  unsigned int );
extern unsigned __int64 _mulx_u64(unsigned __int64 ,
                                  unsigned __int64 ,
                                  unsigned __int64 * );
extern unsigned __int64 _pdep_u64(unsigned __int64 ,
                                  unsigned __int64 );
extern unsigned __int64 _pext_u64(unsigned __int64 ,
                                  unsigned __int64 );
extern unsigned __int64 _rorx_u64(unsigned __int64 ,
                                  const unsigned int );
extern __int64          _sarx_i64(__int64 ,
                                  unsigned int );
extern unsigned __int64 _shlx_u64(unsigned __int64 ,
                                  unsigned int );
extern unsigned __int64 _shrx_u64(unsigned __int64 ,
                                          unsigned int );
#line 1898 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"








extern unsigned int     _lzcnt_u32(unsigned int);

extern unsigned __int64 _lzcnt_u64(unsigned __int64);
#line 1910 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"








extern unsigned __int16 _tzcnt_u16(unsigned __int16);
extern unsigned int     _tzcnt_u32(unsigned int);

extern unsigned __int64 _tzcnt_u64(unsigned __int64);
#line 1923 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);


extern void _Store64_HLERelease(__int64 volatile *,__int64);
extern __int64 _InterlockedExchange64_HLEAcquire(__int64 volatile *,__int64);
extern __int64 _InterlockedExchange64_HLERelease(__int64 volatile *,__int64);

extern __int64 _InterlockedExchangeAdd64_HLEAcquire(__int64 volatile *,__int64);
extern __int64 _InterlockedExchangeAdd64_HLERelease(__int64 volatile *,__int64);

extern __int64 _InterlockedAnd64_HLEAcquire(__int64 volatile *,__int64);
extern __int64 _InterlockedAnd64_HLERelease(__int64 volatile *,__int64);
extern __int64 _InterlockedOr64_HLEAcquire(__int64 volatile *,__int64);
extern __int64 _InterlockedOr64_HLERelease(__int64 volatile *,__int64);
extern __int64 _InterlockedXor64_HLEAcquire(__int64 volatile *,__int64);
extern __int64 _InterlockedXor64_HLERelease(__int64 volatile *,__int64);

extern unsigned char _interlockedbittestandset64_HLEAcquire(__int64 *,__int64);
extern unsigned char _interlockedbittestandset64_HLERelease(__int64 *,__int64);
extern unsigned char _interlockedbittestandreset64_HLEAcquire(__int64 *,__int64);
extern unsigned char _interlockedbittestandreset64_HLERelease(__int64 *,__int64);
#line 1982 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 *);

extern int __cdecl _rdseed64_step(unsigned __int64 *);
#line 2010 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"










extern unsigned char __cdecl _addcarryx_u32(unsigned char ,
                                                   unsigned int ,
                                                   unsigned int ,
                                                   unsigned int * );



extern unsigned char __cdecl _addcarryx_u64(unsigned char ,
                                                   unsigned __int64 ,
                                                   unsigned __int64 ,
                                                   unsigned __int64 * );
#line 2032 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 );

extern __m256i __cdecl _mm256_insert_epi64(__m256i , __int64 , const int );
#line 2088 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 );

extern __int64 __cdecl _mm256_extract_epi64(__m256i , const int );
#line 2096 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

extern void         __cdecl _ptwrite64(unsigned __int64);
#line 2109 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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[]);




extern unsigned __int64 __cdecl _udiv128(unsigned __int64 , unsigned __int64 , unsigned __int64 , unsigned __int64* );
extern __int64          __cdecl _div128(__int64 , __int64 , __int64 , __int64* );
#line 2135 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 *);

extern void             __cdecl _incsspq (unsigned __int64);
extern unsigned __int64 __cdecl _rdsspq (void);
extern void             __cdecl _wrssq (unsigned __int64, void *);
extern void             __cdecl _wrussq(unsigned __int64, void *);
#line 2177 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

extern void _directstoreu_u64(void *, unsigned __int64);
#line 2424 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);



extern void _clui(void);
extern void _stui(void);
extern unsigned char _testui(void);
extern void _senduipi(unsigned __int64);
#line 2443 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2466 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);



extern unsigned __int64 __cdecl _mm_cvtsd_u64(__m128d);
extern unsigned __int64 __cdecl _mm_cvtss_u64(__m128);
extern unsigned __int64 __cdecl _mm_cvttsd_u64(__m128d);
extern unsigned __int64 __cdecl _mm_cvttss_u64(__m128);
extern unsigned __int64 __cdecl _mm_cvt_roundsd_u64(__m128d, int);
extern unsigned __int64 __cdecl _mm_cvt_roundss_u64(__m128, int);
extern unsigned __int64 __cdecl _mm_cvtt_roundsd_u64(__m128d, int);
extern unsigned __int64 __cdecl _mm_cvtt_roundss_u64(__m128, int);

extern __m128d   __cdecl _mm_cvti64_sd(__m128d, __int64);
extern __m128    __cdecl _mm_cvti64_ss(__m128, __int64);
extern __int64   __cdecl _mm_cvtsd_i64(__m128d);
extern __int64   __cdecl _mm_cvtss_i64(__m128);
extern __int64   __cdecl _mm_cvttsd_i64(__m128d);
extern __int64   __cdecl _mm_cvttss_i64(__m128);
extern __int64   __cdecl _mm_cvtt_roundsd_i64(__m128d, int);
extern __int64   __cdecl _mm_cvtt_roundsd_si64(__m128d, int);
extern __int64   __cdecl _mm_cvtt_roundss_i64(__m128, int);
extern __int64   __cdecl _mm_cvtt_roundss_si64(__m128, int);
extern __m128d   __cdecl _mm_cvtu64_sd(__m128d, unsigned __int64);
extern __m128    __cdecl _mm_cvtu64_ss(__m128, unsigned __int64);
extern __m128d   __cdecl _mm_cvt_roundi64_sd(__m128d, __int64, int);
extern __m128    __cdecl _mm_cvt_roundi64_ss(__m128, __int64, int);
extern __int64   __cdecl _mm_cvt_roundsd_i64(__m128d, int);
extern __int64   __cdecl _mm_cvt_roundsd_si64(__m128d, int);
extern __m128d   __cdecl _mm_cvt_roundsi64_sd(__m128d, __int64, int);
extern __m128    __cdecl _mm_cvt_roundsi64_ss(__m128, __int64, int);
extern __int64   __cdecl _mm_cvt_roundss_i64(__m128, int);
extern __int64   __cdecl _mm_cvt_roundss_si64(__m128, int);
extern __m128d   __cdecl _mm_cvt_roundu64_sd(__m128d, unsigned __int64, int);
extern __m128    __cdecl _mm_cvt_roundu64_ss(__m128, unsigned __int64, int);

#line 4352 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 4388 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
typedef unsigned short __bfloat16;

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 __bfloat16 _mm_cvtness_sbh(float);
extern float      _mm_cvtsbh_ss(__bfloat16);
extern __m128     _mm_cvtpbh_ps(__m128bh);
extern __m128     _mm_mask_cvtpbh_ps(__m128, __mmask8, __m128bh);
extern __m128     _mm_maskz_cvtpbh_ps(__mmask8, __m128bh);
extern __m256     _mm256_cvtpbh_ps(__m128bh);
extern __m256     _mm256_mask_cvtpbh_ps(__m256, __mmask8, __m128bh);
extern __m256     _mm256_maskz_cvtpbh_ps(__mmask8, __m128bh);
extern __m512     _mm512_cvtpbh_ps(__m256bh);
extern __m512     _mm512_mask_cvtpbh_ps(__m512, __mmask16, __m256bh);
extern __m512     _mm512_maskz_cvtpbh_ps(__mmask16, __m256bh);




















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 *);




typedef int __tile;

extern void __cdecl _tile_loadconfig(const void *);
extern void __cdecl _tile_storeconfig(void *);
extern void __cdecl _tile_release(void);

extern void __cdecl _tile_loadd(__tile dst, const void *base, int stride);
extern void __cdecl _tile_stream_loadd(__tile dst, const void *base, int stride);
extern void __cdecl _tile_stored(__tile src, void *base, int stride);
extern void __cdecl _tile_zero(__tile dst);

extern void __cdecl _tile_dpbf16ps(__tile dst, __tile src1, __tile src2);
extern void __cdecl _tile_dpfp16ps(__tile dst, __tile src1, __tile src2);
extern void __cdecl _tile_dpbssd(__tile dst, __tile src1, __tile src2);
extern void __cdecl _tile_dpbsud(__tile dst, __tile src1, __tile src2);
extern void __cdecl _tile_dpbusd(__tile dst, __tile src1, __tile src2);
extern void __cdecl _tile_dpbuud(__tile dst, __tile src1, __tile src2);


extern void __cdecl _tile_cmmimfp16ps(__tile dst, __tile src1, __tile src2);
extern void __cdecl _tile_cmmrlfp16ps(__tile dst, __tile src1, __tile src2);

#line 5178 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_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_mask3_fmadd_sch(__m128h, __m128h, __m128h, __mmask8);
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_mask3_fmadd_round_sch(__m128h, __m128h, __m128h, __mmask8, 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 6295 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\zmmintrin.h"


#line 6298 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\zmmintrin.h"
#pragma external_header(pop)
#line 2468 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"


extern "C" {
#line 2472 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"




extern __m128i __cdecl _mm_madd52hi_avx_epu64(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_madd52hi_avx_epu64(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_madd52lo_avx_epu64(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_madd52lo_avx_epu64(__m256i, __m256i, __m256i);


extern __m128 __cdecl _mm_bcstnebf16_ps(const __bfloat16 *);
extern __m256 __cdecl _mm256_bcstnebf16_ps(const __bfloat16 *);
extern __m128 __cdecl _mm_bcstnesh_ps(const void *);
extern __m256 __cdecl _mm256_bcstnesh_ps(const void *);
extern __m128 __cdecl _mm_cvtneebf16_ps(const __m128bh *);
extern __m256 __cdecl _mm256_cvtneebf16_ps(const __m256bh *);
extern __m128 __cdecl _mm_cvtneeph_ps(const __m128h *);
extern __m256 __cdecl _mm256_cvtneeph_ps(const __m256h *);
extern __m128 __cdecl _mm_cvtneobf16_ps(const __m128bh *);
extern __m256 __cdecl _mm256_cvtneobf16_ps(const __m256bh *);
extern __m128 __cdecl _mm_cvtneoph_ps(const __m128h *);
extern __m256 __cdecl _mm256_cvtneoph_ps(const __m256h *);
extern __m128bh __cdecl _mm_cvtneps_avx_pbh(__m128);
extern __m128bh __cdecl _mm256_cvtneps_avx_pbh(__m256);


extern __m128i __cdecl _mm_dpbssd_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbssd_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpbssds_epi32( __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbssds_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpbsud_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbsud_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpbsuds_epi32( __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbsuds_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpbuud_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbuud_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpbuuds_epi32( __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbuuds_epi32(__m256i, __m256i, __m256i);




typedef enum {
  _CMPCCX_O,   
  _CMPCCX_NO,  
  _CMPCCX_B,   
  _CMPCCX_NB,  
  _CMPCCX_Z,   
  _CMPCCX_NZ,  
  _CMPCCX_BE,  
  _CMPCCX_NBE, 
  _CMPCCX_S,   
  _CMPCCX_NS,  
  _CMPCCX_P,   
  _CMPCCX_NP,  
  _CMPCCX_L,   
  _CMPCCX_NL,  
  _CMPCCX_LE,  
  _CMPCCX_NLE, 
} _CMPCCX_ENUM;

extern int __cdecl _cmpccxadd_epi32(void *, int, int, const int);
extern __int64 __cdecl _cmpccxadd_epi64(void *, __int64, __int64, const int);

#line 2537 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"


}; 
#line 2541 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"

#line 2543 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"
#line 2544 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"
#line 2545 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\immintrin.h"
#pragma external_header(pop)
#line 36 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
        #pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"































#pragma once



#line 37 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"



#line 41 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"







#line 49 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"


extern "C" { 
#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

void __lwpval64(unsigned __int64, unsigned int, unsigned int);
unsigned char __lwpins64(unsigned __int64, unsigned int, unsigned int);
#line 277 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

unsigned __int64 _bextr_u64(unsigned __int64, unsigned int, unsigned int);
unsigned __int64 _andn_u64(unsigned __int64, unsigned __int64);
unsigned __int64 _tzcnt_u64(unsigned __int64);
unsigned __int64 _lzcnt_u64(unsigned __int64);
unsigned __int64 _blsr_u64(unsigned __int64);
unsigned __int64 _blsmsk_u64(unsigned __int64);
unsigned __int64 _blsi_u64(unsigned __int64);
#line 295 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

unsigned __int64 _bextri_u64(unsigned __int64, unsigned int);
unsigned __int64 _blcfill_u64(unsigned __int64);
unsigned __int64 _blsfill_u64(unsigned __int64);
unsigned __int64 _blcs_u64(unsigned __int64);
unsigned __int64 _tzmsk_u64(unsigned __int64);
unsigned __int64 _blcic_u64(unsigned __int64);
unsigned __int64 _blsic_u64(unsigned __int64);
unsigned __int64 _t1mskc_u64(unsigned __int64);
unsigned __int64 _blcmsk_u64(unsigned __int64);
unsigned __int64 _blci_u64(unsigned __int64);
#line 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 *);
unsigned __int64 _rdpru(unsigned int);
  


typedef struct rmp_seg {
    unsigned __int64 rmp_gpa;
    __int8           rmp_entry;
    __int8           rmp_pageSize;
    __int8           rmp_pageMark;
    __int8           rmp_reserved;
    __int32          rmp_ASID;
} rmp_seg;

unsigned int __rmpupdate(unsigned __int64, rmp_seg *, int);
unsigned int __pvalidate(unsigned __int64, int, int, int *);
unsigned int __psmash(unsigned __int64);
unsigned int __rmpadjust(unsigned __int64, int, int);
unsigned int __rmpquery(unsigned __int64, int, int);
#line 343 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"



void __svm_invlpgb(void*, int);
void __svm_tlbsync(void);



}; 
#line 353 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"

#line 355 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"
#line 356 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"
#line 357 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ammintrin.h"
#pragma external_header(pop)
#line 37 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
    #line 38 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"

    

#line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"

    


#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"

    


#line 52 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"


extern "C" {
#line 57 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"




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


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);







short _InterlockedAnd16_np(short volatile * _Value, short _Mask);
__int64 _InterlockedAnd64_np(__int64 volatile * _Value, __int64 _Mask);
char _InterlockedAnd8_np(char volatile * _Value, char _Mask);
long _InterlockedAnd_np(long volatile * _Value, long _Mask);
unsigned char _interlockedbittestandset(long volatile *, long);



unsigned char _InterlockedCompareExchange128_np(__int64 volatile * _Destination, __int64 _ExchangeHigh, __int64 _ExchangeLow, __int64 * _ComparandResult);
short _InterlockedCompareExchange16_np(short volatile * _Destination, short _Exchange, short _Comparand);
__int64 _InterlockedCompareExchange64_np(__int64 volatile * _Destination, __int64 _Exchange, __int64 _Comparand);
void * _InterlockedCompareExchangePointer(void * volatile * _Destination, void * _Exchange, void * _Comparand);


void * _InterlockedCompareExchangePointer_np(void * volatile * _Destination, void * _Exchange, void * _Comparand);

long _InterlockedCompareExchange_np(long volatile * _Destination, long _Exchange, long _Comparand);









void * _InterlockedExchangePointer(void * volatile * _Target, void * _Value);











short _InterlockedOr16_np(short volatile * _Value, short _Mask);
__int64 _InterlockedOr64_np(__int64 volatile * _Value, __int64 _Mask);
char _InterlockedOr8_np(char volatile * _Value, char _Mask);
long _InterlockedOr_np(long volatile * _Value, long _Mask);
short _InterlockedXor16_np(short volatile * _Value, short _Mask);
__int64 _InterlockedXor64_np(__int64 volatile * _Value, __int64 _Mask);
char _InterlockedXor8_np(char volatile * _Value, char _Mask);
long _InterlockedXor_np(long volatile * _Value, long _Mask);








void _ReadBarrier(void);






void * _ReturnAddress(void);

void _WriteBarrier(void);









void __addgsbyte(unsigned long, unsigned char);
void __addgsdword(unsigned long, unsigned long);
void __addgsqword(unsigned long, unsigned __int64);
void __addgsword(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);
void __faststorefence(void);
unsigned int __getcallerseflags(void);
void __halt(void);


unsigned char __inbyte(unsigned short);
void __inbytestring(unsigned short, unsigned char *, unsigned long);



void __incgsbyte(unsigned long);
void __incgsdword(unsigned long);
void __incgsqword(unsigned long);
void __incgsword(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 __movsq(unsigned long long *, unsigned long long const *, size_t);
void __movsw(unsigned short *, unsigned short const *, size_t);
__int64 __mulh(__int64, __int64);
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 __int64 __readcr0(void);

unsigned __int64 __readcr2(void);

unsigned __int64 __readcr3(void);

unsigned __int64 __readcr4(void);

unsigned __int64 __readcr8(void);

unsigned __int64 __readdr(unsigned int);

unsigned __int64 __readeflags(void);





unsigned char __readgsbyte(unsigned long);
unsigned long __readgsdword(unsigned long);
unsigned __int64 __readgsqword(unsigned long);
unsigned short __readgsword(unsigned long);
unsigned __int64 __readmsr(unsigned long);
void __readmsrlist(unsigned __int64, unsigned __int64 *, unsigned __int64 *);
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 __stosq(unsigned __int64 *, unsigned __int64, 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);
unsigned __int64 __umulh(unsigned __int64, unsigned __int64);
void __vmx_off(void);
unsigned char __vmx_on(unsigned __int64 *);
unsigned char __vmx_vmclear(unsigned __int64 *);
unsigned char __vmx_vmlaunch(void);
unsigned char __vmx_vmptrld(unsigned __int64 *);
void __vmx_vmptrst(unsigned __int64 *);
unsigned char __vmx_vmread(size_t, size_t *);
unsigned char __vmx_vmresume(void);
unsigned char __vmx_vmwrite(size_t, size_t);
void __wbinvd(void);


void __writecr0(unsigned __int64);

void __writecr2(unsigned __int64);

void __writecr3(unsigned __int64);

void __writecr4(unsigned __int64);

void __writecr8(unsigned __int64);

void __writedr(unsigned int, unsigned __int64);

void __writeeflags(unsigned __int64);





void __writegsbyte(unsigned long, unsigned char);
void __writegsdword(unsigned long, unsigned long);
void __writegsqword(unsigned long, unsigned __int64);
void __writegsword(unsigned long, unsigned short);
void __writemsr(unsigned long, unsigned __int64);
void __writemsrlist(unsigned __int64, unsigned __int64 *, unsigned __int64 *);
void __writemsrns(unsigned long, unsigned __int64);




unsigned char _bittest64(__int64 const *, __int64);
unsigned char _bittestandcomplement(long *, long);
unsigned char _bittestandcomplement64(__int64 *, __int64);
unsigned char _bittestandreset(long *, long);
unsigned char _bittestandreset64(__int64 *, __int64);
unsigned char _bittestandset(long *, long);
unsigned char _bittestandset64(__int64 *, __int64);
[[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);
unsigned char _interlockedbittestandreset64(__int64 volatile *, __int64);






unsigned char _interlockedbittestandset64(__int64 volatile *, __int64);













[[nodiscard]]   unsigned long __cdecl _lrotl(  unsigned long,   int);
[[nodiscard]]   unsigned long __cdecl _lrotr(  unsigned long,   int);




























































void _m_prefetch(void *);
void _m_prefetchw(volatile const void *);



































__m128i _mm_abs_epi16(__m128i);
__m128i _mm_abs_epi32(__m128i);
__m128i _mm_abs_epi8(__m128i);



__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);

__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);

__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 __int64 _mm_crc32_u64(unsigned __int64, unsigned __int64);
unsigned int _mm_crc32_u8(unsigned int, unsigned char);


__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);

__m128 _mm_cvtpd_ps(__m128d);

__m128i _mm_cvtps_epi32(__m128);
__m128d _mm_cvtps_pd(__m128);
int _mm_cvtsd_si32(__m128d);
__int64 _mm_cvtsd_si64(__m128d);
__int64 _mm_cvtsd_si64x(__m128d);
__m128 _mm_cvtsd_ss(__m128, __m128d);
int _mm_cvtsi128_si32(__m128i);
__int64 _mm_cvtsi128_si64(__m128i);
__int64 _mm_cvtsi128_si64x(__m128i);
__m128d _mm_cvtsi32_sd(__m128d, int);
__m128i _mm_cvtsi32_si128(int);
__m128d _mm_cvtsi64_sd(__m128d, __int64);
__m128i _mm_cvtsi64_si128(__int64);
__m128 _mm_cvtsi64_ss(__m128, __int64);
__m128d _mm_cvtsi64x_sd(__m128d, __int64);
__m128i _mm_cvtsi64x_si128(__int64);
__m128 _mm_cvtsi64x_ss(__m128, __int64);
__m128d _mm_cvtss_sd(__m128d, __m128);
__int64 _mm_cvtss_si64(__m128);
__int64 _mm_cvtss_si64x(__m128);

int _mm_cvtt_ss2si(__m128);
__m128i _mm_cvttpd_epi32(__m128d);

__m128i _mm_cvttps_epi32(__m128);
int _mm_cvttsd_si32(__m128d);
__int64 _mm_cvttsd_si64(__m128d);
__int64 _mm_cvttsd_si64x(__m128d);
__int64 _mm_cvttss_si64(__m128);
__int64 _mm_cvttss_si64x(__m128);
__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);
__int64 _mm_extract_epi64(__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);


__m128 _mm_hadd_ps(__m128, __m128);
__m128i _mm_hadds_epi16(__m128i, __m128i);

__m128i _mm_hsub_epi16(__m128i, __m128i);
__m128i _mm_hsub_epi32(__m128i, __m128i);
__m128d _mm_hsub_pd(__m128d, __m128d);


__m128 _mm_hsub_ps(__m128, __m128);
__m128i _mm_hsubs_epi16(__m128i, __m128i);

__m128i _mm_insert_epi16(__m128i, int, int);
__m128i _mm_insert_epi32(__m128i, int, int);
__m128i _mm_insert_epi64(__m128i, __int64, 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);

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);


__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);

__m128i _mm_mulhi_epi16(__m128i, __m128i);
__m128i _mm_mulhi_epu16(__m128i, __m128i);
__m128i _mm_mulhrs_epi16(__m128i, __m128i);

__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);
__int64 _mm_popcnt_u64(unsigned __int64);
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_epi64x(__int64);
__m128i _mm_set1_epi8(char);
__m128d _mm_set1_pd(double);



__m128i _mm_set_epi16(short, short, short, short, short, short, short, short);
__m128i _mm_set_epi32(int, int, int, int);

__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);



__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_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);



__m128 _mm_setr_ps(float, float, float, float);
__m128d _mm_setzero_pd(void);
__m128 _mm_setzero_ps(void);
__m128i _mm_setzero_si128(void);

void _mm_sfence(void);
__m128i _mm_shuffle_epi32(__m128i, int);
__m128i _mm_shuffle_epi8(__m128i, __m128i);
__m128d _mm_shuffle_pd(__m128d, __m128d, int);

__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);



__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 884 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
__m128i _mm_stream_load_si128(const __m128i *);
#line 886 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
void _mm_stream_pd(double *, __m128d);

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_si64x(__int64 *, __int64);
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);

__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);
__int64 _mul128(__int64 _Multiplier, __int64 _Multiplicand, __int64 * _HighProduct);
int __cdecl _setjmp(jmp_buf);
int __cdecl _setjmpex(jmp_buf);
void _rsm(void);
void _lgdt(void *);
void _sgdt(void *);
void _clac(void);
void _stac(void);
unsigned char _addcarry_u8(unsigned char, unsigned char, unsigned char, unsigned char *);
unsigned char _subborrow_u8(unsigned char, unsigned char, unsigned char, unsigned char *);
unsigned char _addcarry_u16(unsigned char, unsigned short, unsigned short, unsigned short *);
unsigned char _subborrow_u16(unsigned char, unsigned short, unsigned short, unsigned short *);
unsigned char _addcarry_u32(unsigned char, unsigned int, unsigned int, unsigned int *);
unsigned char _subborrow_u32(unsigned char, unsigned int, unsigned int, unsigned int *);
unsigned char _add_overflow_i8(unsigned char, signed char, signed char, signed char *);
unsigned char _add_overflow_i16(unsigned char, signed short, signed short, signed short *);
unsigned char _add_overflow_i32(unsigned char, signed int, signed int, signed int *);
unsigned char _add_overflow_i64(unsigned char, signed __int64, signed __int64, signed __int64 *);
unsigned char _sub_overflow_i8(unsigned char, signed char, signed char, signed char *);
unsigned char _sub_overflow_i16(unsigned char, signed short, signed short, signed short *);
unsigned char _sub_overflow_i32(unsigned char, signed int, signed int, signed int *);
unsigned char _sub_overflow_i64(unsigned char, signed __int64, signed __int64, signed __int64 *);
unsigned char _mul_overflow_i16(signed short, signed short, signed short *);
unsigned char _mul_overflow_i32(signed int, signed int, signed int *);
unsigned char _mul_overflow_i64(signed __int64, signed __int64, signed __int64 *);
unsigned char _mul_full_overflow_i8(signed char, signed char, signed short *);
unsigned char _mul_full_overflow_i16(signed short, signed short, signed short *, signed short *);
unsigned char _mul_full_overflow_i32(signed int, signed int, signed int *, signed int *);
unsigned char _mul_full_overflow_i64(signed __int64, signed __int64, signed __int64 *, signed __int64 *);
unsigned char _mul_full_overflow_u8(unsigned char, unsigned char, unsigned short *);
unsigned char _mul_full_overflow_u16(unsigned short, unsigned short, unsigned short *, unsigned short *);
unsigned char _mul_full_overflow_u32(unsigned int, unsigned int, unsigned int *, unsigned int *);
unsigned char _mul_full_overflow_u64(unsigned __int64, unsigned __int64, unsigned __int64 *, unsigned __int64 *);
void _mm_monitorx(void const *, unsigned int, unsigned int);
void _mm_mwaitx(unsigned int, unsigned int, unsigned int);
unsigned __int64 _rdpru(unsigned int);
unsigned int __rmpupdate(unsigned __int64, rmp_seg *, int);
unsigned int __psmash(unsigned __int64);
unsigned int __rmpadjust(unsigned __int64, int, int);
unsigned int __pvalidate(unsigned __int64, int, int, int*);
void __svm_invlpgb(void*, int);
void __svm_tlbsync(void);
void * _AddressOfNextInstruction(void);
unsigned char __is_unorderedf(float, float);
unsigned char __is_unordered(double, double);
unsigned char __is_unorderedl(long double, long double);
unsigned char __is_nanf(float);
unsigned char __is_nan(double);
unsigned char __is_nanl(long double);
unsigned char __is_normalf(float);
unsigned char __is_normal(double);
unsigned char __is_normall(long double);
unsigned char __is_finitef(float);
unsigned char __is_finite(double);
unsigned char __is_finitel(long double);
unsigned char __is_infinityf(float);
unsigned char __is_infinity(double);
unsigned char __is_infinityl(long double);
unsigned char __is_subnormalf(float);
unsigned char __is_subnormal(double);
unsigned char __is_subnormall(long double);
float __fminf(float, float);
double __fmin(double, double);
long double __fminl(long double, long double);
float __fmaxf(float, float);
double __fmax(double, double);
long double __fmaxl(long double, long double);

#pragma warning(pop) 



    





#line 1016 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"

#line 1018 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"


}
#line 1022 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
#pragma warning(pop) 
#line 1024 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"

#line 1026 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\intrin.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"


__pragma(warning(push))
__pragma(warning(disable: 4996))





namespace QAlgorithmsPrivate {


















#line 77 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"

}











































































































































































































































#line 315 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"

template <typename ForwardIterator>
inline void qDeleteAll(ForwardIterator begin, ForwardIterator end)
{
    while (begin != end) {
        delete *begin;
        ++begin;
    }
}

template <typename Container>
inline void qDeleteAll(const Container &c)
{
    qDeleteAll(c.begin(), c.end());
}





namespace QAlgorithmsPrivate {
























































































































































































#line 521 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"










#line 532 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"



























































#line 592 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"



__forceinline unsigned long qt_builtin_ctz(quint32 val)
{
    unsigned long result;
    _BitScanForward(&result, val);
    return result;
}

__forceinline unsigned long qt_builtin_clz(quint32 val)
{
    unsigned long result;
    _BitScanReverse(&result, val);
    
    
    
    result ^= sizeof(quint32) * 8 - 1;
    return result;
}



__forceinline unsigned long qt_builtin_ctzll(quint64 val)
{
    unsigned long result;
    _BitScanForward64(&result, val);
    return result;
}


__forceinline unsigned long qt_builtin_clzll(quint64 val)
{
    unsigned long result;
    _BitScanReverse64(&result, val);
    
    result ^= sizeof(quint64) * 8 - 1;
    return result;
}
#line 632 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"

__forceinline uint qt_builtin_ctzs(quint16 v) noexcept
{
    return qt_builtin_ctz(v);
}

__forceinline uint qt_builtin_clzs(quint16 v) noexcept
{
    return qt_builtin_clz(v) - 16U;
}


































#line 677 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"

#line 679 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
#line 680 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"






} 

  inline uint qPopulationCount(quint32 v) noexcept
{



    
    return
        (((v      ) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 12) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 24) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f;
#line 699 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

  inline uint qPopulationCount(quint8 v) noexcept
{



    return
        (((v      ) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f;
#line 709 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

  inline uint qPopulationCount(quint16 v) noexcept
{



    return
        (((v      ) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 12) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f;
#line 720 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

  inline uint qPopulationCount(quint64 v) noexcept
{



    return
        (((v      ) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 12) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 24) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 36) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 48) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f +
        (((v >> 60) & 0xfff)    * 0x1001001001001ui64 & 0x84210842108421ui64) % 0x1f;
#line 735 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

  inline uint qPopulationCount(long unsigned int v) noexcept
{
    return qPopulationCount(static_cast<quint64>(v));
}



#line 745 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"


constexpr inline uint qCountTrailingZeroBits(quint32 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_ctz(v) : 32U;











#line 763 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

constexpr inline uint qCountTrailingZeroBits(quint8 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_ctz(v) : 8U;








#line 778 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

constexpr inline uint qCountTrailingZeroBits(quint16 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_ctzs(v) : 16U;









#line 794 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

constexpr inline uint qCountTrailingZeroBits(quint64 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_ctzll(v) : 64;




#line 805 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

constexpr inline uint qCountTrailingZeroBits(unsigned long v) noexcept
{
    return qCountTrailingZeroBits(QIntegerForSizeof<long>::Unsigned(v));
}

constexpr inline uint qCountLeadingZeroBits(quint32 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_clz(v) : 32U;








#line 825 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

 inline uint qCountLeadingZeroBits(quint8 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_clz(v)-24U : 8U;





#line 837 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

 inline uint qCountLeadingZeroBits(quint16 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_clzs(v) : 16U;






#line 850 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

 inline uint qCountLeadingZeroBits(quint64 v) noexcept
{

    return v ? QAlgorithmsPrivate::qt_builtin_clzll(v) : 64U;








#line 865 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
}

 inline uint qCountLeadingZeroBits(unsigned long v) noexcept
{
    return qCountLeadingZeroBits(QIntegerForSizeof<long>::Unsigned(v));
}

__pragma(warning(pop))


#line 876 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qalgorithms.h"
#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"












































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiterator.h"




























































































































































































#line 190 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiterator.h"

template<typename Key, typename T, class Iterator>
class QKeyValueIterator
{
public:
    typedef typename Iterator::iterator_category iterator_category;
    typedef typename Iterator::difference_type difference_type;
    typedef std::pair<Key, T> value_type;
    typedef const value_type &reference;

    QKeyValueIterator() = default;
    constexpr explicit QKeyValueIterator(Iterator o) noexcept(std::is_nothrow_move_constructible<Iterator>::value)
        : i(std::move(o)) {}

    std::pair<Key, T> operator*() const {
        return std::pair<Key, T>(i.key(), i.value());
    }

    struct pointer {
        pointer(value_type&& r_)
            : r(std::move(r_))
        {}

        pointer() = default;
        pointer(const pointer &other) = default;
        pointer(pointer &&other) = default;
        pointer& operator=(const pointer &other) = default;
        pointer& operator=(pointer &&other) = default;

        value_type& operator*() const {
            return r;
        }

        value_type r;
        const value_type *operator->() const {
            return &r;
        }
    };

    pointer operator->() const {
        return pointer(std::pair<Key, T>(i.key(), i.value()));
    }

    friend bool operator==(QKeyValueIterator lhs, QKeyValueIterator rhs) noexcept { return lhs.i == rhs.i; }
    friend bool operator!=(QKeyValueIterator lhs, QKeyValueIterator rhs) noexcept { return lhs.i != rhs.i; }

    inline QKeyValueIterator &operator++() { ++i; return *this; }
    inline QKeyValueIterator operator++(int) { return QKeyValueIterator(i++);}
    inline QKeyValueIterator &operator--() { --i; return *this; }
    inline QKeyValueIterator operator--(int) { return QKeyValueIterator(i--); }
    Iterator base() const { return i; }

private:
    Iterator i;
};



#line 249 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiterator.h"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"















































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"















































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"











































#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"









namespace QtPrivate
{
template <typename Iterator>
using IfIsInputIterator = typename std::enable_if<
    std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::input_iterator_tag>::value,
    bool>::type;

template <typename Iterator>
using IfIsForwardIterator = typename std::enable_if<
    std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value,
    bool>::type;

template <typename Iterator>
using IfIsNotForwardIterator = typename std::enable_if<
    !std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value,
    bool>::type;

template <typename Container,
          typename InputIterator,
          IfIsNotForwardIterator<InputIterator> = true>
void reserveIfForwardIterator(Container *, InputIterator, InputIterator)
{
}

template <typename Container,
          typename ForwardIterator,
          IfIsForwardIterator<ForwardIterator> = true>
void reserveIfForwardIterator(Container *c, ForwardIterator f, ForwardIterator l)
{
    c->reserve(static_cast<typename Container::size_type>(std::distance(f, l)));
}


template <typename ... T>
using void_t = void;

template <typename Iterator, typename = void_t<>>
struct AssociativeIteratorHasKeyAndValue : std::false_type
{
};

template <typename Iterator>
struct AssociativeIteratorHasKeyAndValue<
        Iterator,
        void_t<decltype(std::declval<Iterator &>().key()),
               decltype(std::declval<Iterator &>().value())>
    >
    : std::true_type
{
};

template <typename Iterator, typename = void_t<>, typename = void_t<>>
struct AssociativeIteratorHasFirstAndSecond : std::false_type
{
};

template <typename Iterator>
struct AssociativeIteratorHasFirstAndSecond<
        Iterator,
        void_t<decltype(std::declval<Iterator &>()->first),
               decltype(std::declval<Iterator &>()->second)>
    >
    : std::true_type
{
};

template <typename Iterator>
using IfAssociativeIteratorHasKeyAndValue =
    typename std::enable_if<AssociativeIteratorHasKeyAndValue<Iterator>::value, bool>::type;

template <typename Iterator>
using IfAssociativeIteratorHasFirstAndSecond =
    typename std::enable_if<AssociativeIteratorHasFirstAndSecond<Iterator>::value, bool>::type;

} 



#line 133 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"





#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"







template <typename T>
class QVector
{
    typedef QTypedArrayData<T> Data;
    Data *d;

public:
    inline QVector() noexcept : d(Data::sharedNull()) { }
    explicit QVector(int size);
    QVector(int size, const T &t);
    inline QVector(const QVector<T> &v);
    inline ~QVector() { if (!d->ref.deref()) freeData(d); }
    QVector<T> &operator=(const QVector<T> &v);
    QVector(QVector<T> &&other) noexcept : d(other.d) { other.d = Data::sharedNull(); }
    QVector<T> &operator=(QVector<T> &&other) noexcept
    { QVector moved(std::move(other)); swap(moved); return *this; }
    void swap(QVector<T> &other) noexcept { qSwap(d, other.d); }
    inline QVector(std::initializer_list<T> args);
    QVector<T> &operator=(std::initializer_list<T> args);
    template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
    inline QVector(InputIterator first, InputIterator last);
    explicit QVector(QArrayDataPointerRef<T> ref) noexcept : d(ref.ptr) {}

    bool operator==(const QVector<T> &v) const;
    inline bool operator!=(const QVector<T> &v) const { return !(*this == v); }

    inline int size() const { return d->size; }

    inline bool isEmpty() const { return d->size == 0; }

    void resize(int size);

    inline int capacity() const { return int(d->alloc); }
    void reserve(int size);
    inline void squeeze()
    {
        if (d->size < int(d->alloc)) {
            if (!d->size) {
                *this = QVector<T>();
                return;
            }
            realloc(d->size);
        }
        if (d->capacityReserved) {
            
            
            d->capacityReserved = 0;
        }
    }

    inline void detach();
    inline bool isDetached() const { return !d->ref.isShared(); }

    inline void setSharable(bool sharable)
    {
        if (sharable == d->ref.isSharable())
            return;
        if (!sharable)
            detach();

        if (d == Data::unsharableEmpty()) {
            if (sharable)
                d = Data::sharedNull();
        } else {
            d->ref.setSharable(sharable);
        }
        ((d->ref.isSharable() == sharable) ? static_cast<void>(0) : qt_assert("d->ref.isSharable() == sharable", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 128));
    }
#line 131 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

    inline bool isSharedWith(const QVector<T> &other) const { return d == other.d; }

    inline T *data() { detach(); return d->begin(); }
    inline const T *data() const { return d->begin(); }
    inline const T *constData() const { return d->begin(); }
    void clear();

    const T &at(int i) const;
    T &operator[](int i);
    const T &operator[](int i) const;
    void append(const T &t);
    void append(T &&t);
    inline void append(const QVector<T> &l) { *this += l; }
    void prepend(T &&t);
    void prepend(const T &t);
    void insert(int i, T &&t);
    void insert(int i, const T &t);
    void insert(int i, int n, const T &t);
    void replace(int i, const T &t);
    void remove(int i);
    void remove(int i, int n);
    inline void removeFirst() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 153)); erase(d->begin()); }
    inline void removeLast();
    T takeFirst() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 155)); T r = std::move(first()); removeFirst(); return r; }
    T takeLast()  { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 156)); T r = std::move(last()); removeLast(); return r; }

    QVector<T> &fill(const T &t, int size = -1);

    int indexOf(const T &t, int from = 0) const;
    int lastIndexOf(const T &t, int from = -1) const;
    bool contains(const T &t) const;
    int count(const T &t) const;

    
    void removeAt(int i) { remove(i); }
    int removeAll(const T &t)
    {
        const const_iterator ce = this->cend(), cit = std::find(this->cbegin(), ce, t);
        if (cit == ce)
            return 0;
        
        const T tCopy = t;
        const int firstFoundIdx = std::distance(this->cbegin(), cit);
        const iterator e = end(), it = std::remove(begin() + firstFoundIdx, e, tCopy);
        const int result = std::distance(it, e);
        erase(it, e);
        return result;
    }
    bool removeOne(const T &t)
    {
        const int i = indexOf(t);
        if (i < 0)
            return false;
        remove(i);
        return true;
    }
    int length() const { return size(); }
    T takeAt(int i) { T t = std::move((*this)[i]); remove(i); return t; }
    void move(int from, int to)
    {
        ((from >= 0 && from < size()) ? static_cast<void>(0) : qt_assert_x("QVector::move(int,int)", "'from' is out-of-range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 192));
        ((to >= 0 && to < size()) ? static_cast<void>(0) : qt_assert_x("QVector::move(int,int)", "'to' is out-of-range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 193));
        if (from == to) 
            return;
        detach();
        T * const b = d->begin();
        if (from < to)
            std::rotate(b + from, b + from + 1, b + to + 1);
        else
            std::rotate(b + to, b + from, b + from + 1);
    }

    
    typedef typename Data::iterator iterator;
    typedef typename Data::const_iterator const_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;









#line 219 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
    inline iterator begin(iterator = iterator()) { detach(); return d->begin(); }
    inline const_iterator begin(const_iterator = const_iterator()) const noexcept { return d->constBegin(); }
    inline const_iterator cbegin(const_iterator = const_iterator()) const noexcept { return d->constBegin(); }
    inline const_iterator constBegin(const_iterator = const_iterator()) const noexcept { return d->constBegin(); }
    inline iterator end(iterator = iterator()) { detach(); return d->end(); }
    inline const_iterator end(const_iterator = const_iterator()) const noexcept { return d->constEnd(); }
    inline const_iterator cend(const_iterator = const_iterator()) const noexcept { return d->constEnd(); }
    inline const_iterator constEnd(const_iterator = const_iterator()) const noexcept { return d->constEnd(); }
#line 228 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
    iterator insert(iterator before, int n, const T &x);
    inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
    inline iterator insert(iterator before, T &&x);
    iterator erase(iterator begin, iterator end);
    inline iterator erase(iterator pos) { return erase(pos, pos+1); }

    
    inline int count() const { return d->size; }
    inline T& first() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 242)); return *begin(); }
    inline const T &first() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 243)); return *begin(); }
    inline const T &constFirst() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 244)); return *begin(); }
    inline T& last() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 245)); return *(end()-1); }
    inline const T &last() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 246)); return *(end()-1); }
    inline const T &constLast() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 247)); return *(end()-1); }
    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
    QVector<T> mid(int pos, int len = -1) const;

    T value(int i) const;
    T value(int i, const T &defaultValue) const;

    void swapItemsAt(int i, int j) {
        ((i >= 0 && i < size() && j >= 0 && j < size()) ? static_cast<void>(0) : qt_assert_x("QVector<T>::swap", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 257));
#line 258 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
        detach();
        qSwap(d->begin()[i], d->begin()[j]);
    }

    
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef qptrdiff difference_type;
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    typedef int size_type;
    inline void push_back(const T &t) { append(t); }
    void push_back(T &&t) { append(std::move(t)); }
    void push_front(T &&t) { prepend(std::move(t)); }
    inline void push_front(const T &t) { prepend(t); }
    void pop_back() { removeLast(); }
    void pop_front() { removeFirst(); }
    inline bool empty() const
    { return d->size == 0; }
    inline T& front() { return first(); }
    inline const_reference front() const { return first(); }
    inline reference back() { return last(); }
    inline const_reference back() const { return last(); }
    void shrink_to_fit() { squeeze(); }

    
    QVector<T> &operator+=(const QVector<T> &l);
    inline QVector<T> operator+(const QVector<T> &l) const
    { QVector n = *this; n += l; return n; }
    inline QVector<T> &operator+=(const T &t)
    { append(t); return *this; }
    inline QVector<T> &operator<< (const T &t)
    { append(t); return *this; }
    inline QVector<T> &operator<<(const QVector<T> &l)
    { *this += l; return *this; }
    inline QVector<T> &operator+=(T &&t)
    { append(std::move(t)); return *this; }
    inline QVector<T> &operator<<(T &&t)
    { append(std::move(t)); return *this; }

    static QVector<T> fromList(const QList<T> &list);
    QList<T> toList() const;








#line 312 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
private:
    
    void reallocData(const int size, const int alloc, QArrayData::AllocationOptions options = QArrayData::Default);
    void reallocData(const int sz) { reallocData(sz, d->alloc); }
    void realloc(int alloc, QArrayData::AllocationOptions options = QArrayData::Default);
    void freeData(Data *d);
    void defaultConstruct(T *from, T *to);
    void copyConstruct(const T *srcFrom, const T *srcTo, T *dstFrom);
    void destruct(T *from, T *to);
    bool isValidIterator(const iterator &i) const
    {
        const std::less<const T*> less = {};
        return !less(d->end(), i) && !less(i, d->begin());
    }
    class AlignmentDummy { Data header; T array[1]; };
};


template <typename InputIterator,
          typename ValueType = typename std::iterator_traits<InputIterator>::value_type,
          QtPrivate::IfIsInputIterator<InputIterator> = true>
QVector(InputIterator, InputIterator) -> QVector<ValueType>;
#line 335 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"




#pragma warning ( push )
#pragma warning(disable : 4127) 
#line 342 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

template <typename T>
void QVector<T>::defaultConstruct(T *from, T *to)
{
    while (from != to)
        new (from++) T();
}

template <typename T>
void QVector<T>::copyConstruct(const T *srcFrom, const T *srcTo, T *dstFrom)
{
    if (QTypeInfo<T>::isComplex) {
        while (srcFrom != srcTo)
            new (dstFrom++) T(*srcFrom++);
    } else {
        ::memcpy(static_cast<void *>(dstFrom), static_cast<const void *>(srcFrom), (srcTo - srcFrom) * sizeof(T));
    }
}

template <typename T>
void QVector<T>::destruct(T *from, T *to)
{
    if (QTypeInfo<T>::isComplex) {
        while (from != to) {
            from++->~T();
        }
    }
}

template <typename T>
inline QVector<T>::QVector(const QVector<T> &v)
{
    if (v.d->ref.ref()) {
        d = v.d;
    } else {
        if (v.d->capacityReserved) {
            d = Data::allocate(v.d->alloc);
            do { if (!(d)) qBadAlloc(); } while (false);
            d->capacityReserved = true;
        } else {
            d = Data::allocate(v.d->size);
            do { if (!(d)) qBadAlloc(); } while (false);
        }
        if (d->alloc) {
            copyConstruct(v.d->begin(), v.d->end(), d->begin());
            d->size = v.d->size;
        }
    }
}


#pragma warning( pop )
#line 395 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

template <typename T>
void QVector<T>::detach()
{
    if (!isDetached()) {

        if (!d->alloc)
            d = Data::unsharableEmpty();
        else
#line 405 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
            realloc(int(d->alloc));
    }
    ((isDetached()) ? static_cast<void>(0) : qt_assert("isDetached()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 407));
}

template <typename T>
void QVector<T>::reserve(int asize)
{
    if (asize > int(d->alloc))
        realloc(asize);
    if (isDetached()

            && d != Data::unsharableEmpty()
#line 419 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
            )
        d->capacityReserved = 1;
    ((capacity() >= asize) ? static_cast<void>(0) : qt_assert("capacity() >= asize", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 421));
}

template <typename T>
void QVector<T>::resize(int asize)
{
    if (asize == d->size)
        return detach();
    if (asize > int(d->alloc) || !isDetached()) { 
        QArrayData::AllocationOptions opt = asize > int(d->alloc) ? QArrayData::Grow : QArrayData::Default;
        realloc(qMax(int(d->alloc), asize), opt);
    }
    if (asize < d->size)
        destruct(begin() + asize, end());
    else
        defaultConstruct(end(), begin() + asize);
    d->size = asize;
}
template <typename T>
inline void QVector<T>::clear()
{
    if (!d->size)
        return;
    destruct(begin(), end());
    d->size = 0;
}
template <typename T>
inline const T &QVector<T>::at(int i) const
{ ((i >= 0 && i < d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::at", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 449));
  return d->begin()[i]; }
template <typename T>
inline const T &QVector<T>::operator[](int i) const
{ ((i >= 0 && i < d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::operator[]", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 453));
  return d->begin()[i]; }
template <typename T>
inline T &QVector<T>::operator[](int i)
{ ((i >= 0 && i < d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::operator[]", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 457));
  return data()[i]; }
template <typename T>
inline void QVector<T>::insert(int i, const T &t)
{ ((i >= 0 && i <= d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 461));
  insert(begin() + i, 1, t); }
template <typename T>
inline void QVector<T>::insert(int i, int n, const T &t)
{ ((i >= 0 && i <= d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 465));
  insert(begin() + i, n, t); }
template <typename T>
inline void QVector<T>::insert(int i, T &&t)
{ ((i >= 0 && i <= d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 469));
  insert(begin() + i, std::move(t)); }
template <typename T>
inline void QVector<T>::remove(int i, int n)
{ ((i >= 0 && n >= 0 && i + n <= d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::remove", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 473));
  erase(d->begin() + i, d->begin() + i + n); }
template <typename T>
inline void QVector<T>::remove(int i)
{ ((i >= 0 && i < d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::remove", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 477));
  erase(d->begin() + i, d->begin() + i + 1); }
template <typename T>
inline void QVector<T>::prepend(const T &t)
{ insert(begin(), 1, t); }
template <typename T>
inline void QVector<T>::prepend(T &&t)
{ insert(begin(), std::move(t)); }

template <typename T>
inline void QVector<T>::replace(int i, const T &t)
{
    ((i >= 0 && i < d->size) ? static_cast<void>(0) : qt_assert_x("QVector<T>::replace", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 489));
    const T copy(t);
    data()[i] = copy;
}

template <typename T>
QVector<T> &QVector<T>::operator=(const QVector<T> &v)
{
    if (v.d != d) {
        QVector<T> tmp(v);
        tmp.swap(*this);
    }
    return *this;
}

template <typename T>
QVector<T>::QVector(int asize)
{
    ((asize >= 0) ? static_cast<void>(0) : qt_assert_x("QVector::QVector", "Size must be greater than or equal to 0.", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 507));
    if ((asize > 0)) {
        d = Data::allocate(asize);
        do { if (!(d)) qBadAlloc(); } while (false);
        d->size = asize;
        defaultConstruct(d->begin(), d->end());
    } else {
        d = Data::sharedNull();
    }
}

template <typename T>
QVector<T>::QVector(int asize, const T &t)
{
    ((asize >= 0) ? static_cast<void>(0) : qt_assert_x("QVector::QVector", "Size must be greater than or equal to 0.", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 521));
    if (asize > 0) {
        d = Data::allocate(asize);
        do { if (!(d)) qBadAlloc(); } while (false);
        d->size = asize;
        auto i = d->end();
        while (i != d->begin())
            new (--i) T(t);
    } else {
        d = Data::sharedNull();
    }
}


__pragma(warning(push))
__pragma(warning(disable: 4127)) 
#line 538 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

template <typename T>
QVector<T>::QVector(std::initializer_list<T> args)
{
    if (args.size() > 0) {
        d = Data::allocate(args.size());
        do { if (!(d)) qBadAlloc(); } while (false);
        
        
        copyConstruct(args.begin(), args.end(), d->begin());
        d->size = int(args.size());
    } else {
        d = Data::sharedNull();
    }
}

template <typename T>
QVector<T> &QVector<T>::operator=(std::initializer_list<T> args)
{
    QVector<T> tmp(args);
    tmp.swap(*this);
    return *this;
}


__pragma(warning(pop))
#line 565 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

template <typename T>
template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator>>
QVector<T>::QVector(InputIterator first, InputIterator last)
    : QVector()
{
    QtPrivate::reserveIfForwardIterator(this, first, last);
    std::copy(first, last, std::back_inserter(*this));
}

template <typename T>
void QVector<T>::freeData(Data *x)
{
    destruct(x->begin(), x->end());
    Data::deallocate(x);
}


__pragma(warning(push))
__pragma(warning(disable: 4127)) 
#line 586 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

template <typename T>
void QVector<T>::reallocData(const int asize, const int aalloc, QArrayData::AllocationOptions options)
{
    ((asize >= 0 && asize <= aalloc) ? static_cast<void>(0) : qt_assert("asize >= 0 && asize <= aalloc", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 590));
    Data *x = d;

    const bool isShared = d->ref.isShared();

    if (aalloc != 0) {
        if (aalloc != int(d->alloc) || isShared) {
            try {
                
                x = Data::allocate(aalloc, options);
                do { if (!(x)) qBadAlloc(); } while (false);
                

                ((x->ref.isSharable() || options.testFlag(QArrayData::Unsharable)) ? static_cast<void>(0) : qt_assert("x->ref.isSharable() || options.testFlag(QArrayData::Unsharable)", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 603));
#line 605 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
                ((!x->ref.isStatic()) ? static_cast<void>(0) : qt_assert("!x->ref.isStatic()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 605));
                x->size = asize;

                T *srcBegin = d->begin();
                T *srcEnd = asize > d->size ? d->end() : d->begin() + asize;
                T *dst = x->begin();

                if (!QTypeInfoQuery<T>::isRelocatable || (isShared && QTypeInfo<T>::isComplex)) {
                    try {
                        if (isShared || !std::is_nothrow_move_constructible<T>::value) {
                            
                            while (srcBegin != srcEnd)
                                new (dst++) T(*srcBegin++);
                        } else {
                            while (srcBegin != srcEnd)
                                new (dst++) T(std::move(*srcBegin++));
                        }
                    } catch (...) {
                        
                        destruct(x->begin(), dst);
                        throw;
                    }
                } else {
                    ::memcpy(static_cast<void *>(dst), static_cast<void *>(srcBegin), (srcEnd - srcBegin) * sizeof(T));
                    dst += srcEnd - srcBegin;

                    
                    if (asize < d->size)
                        destruct(d->begin() + asize, d->end());
                }

                if (asize > d->size) {
                    
                    try {
                        while (dst != x->end())
                            new (dst++) T();
                    } catch (...) {
                        
                        destruct(x->begin(), dst);
                        throw;
                    }
                }
            } catch (...) {
                Data::deallocate(x);
                throw;
            }
            x->capacityReserved = d->capacityReserved;
        } else {
            ((int(d->alloc) == aalloc) ? static_cast<void>(0) : qt_assert("int(d->alloc) == aalloc", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 653)); 
            ((isDetached()) ? static_cast<void>(0) : qt_assert("isDetached()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 654));       
            ((x == d) ? static_cast<void>(0) : qt_assert("x == d", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 655));             
            if (asize <= d->size) {
                destruct(x->begin() + asize, x->end()); 
            } else {
                defaultConstruct(x->end(), x->begin() + asize); 
            }
            x->size = asize;
        }
    } else {
        x = Data::sharedNull();
    }
    if (d != x) {
        if (!d->ref.deref()) {
            if (!QTypeInfoQuery<T>::isRelocatable || !aalloc || (isShared && QTypeInfo<T>::isComplex)) {
                
                
                freeData(d);
            } else {
                Data::deallocate(d);
            }
        }
        d = x;
    }

    ((d->data()) ? static_cast<void>(0) : qt_assert("d->data()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 679));
    ((uint(d->size) <= d->alloc) ? static_cast<void>(0) : qt_assert("uint(d->size) <= d->alloc", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 680));

    ((d != Data::unsharableEmpty()) ? static_cast<void>(0) : qt_assert("d != Data::unsharableEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 682));
#line 684 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
    ((aalloc ? d != Data::sharedNull() : d == Data::sharedNull()) ? static_cast<void>(0) : qt_assert("aalloc ? d != Data::sharedNull() : d == Data::sharedNull()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 684));
    ((d->alloc >= uint(aalloc)) ? static_cast<void>(0) : qt_assert("d->alloc >= uint(aalloc)", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 685));
    ((d->size == asize) ? static_cast<void>(0) : qt_assert("d->size == asize", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 686));
}

template<typename T>
void QVector<T>::realloc(int aalloc, QArrayData::AllocationOptions options)
{
    ((aalloc >= d->size) ? static_cast<void>(0) : qt_assert("aalloc >= d->size", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 692));
    Data *x = d;

    const bool isShared = d->ref.isShared();

    try {
        
        x = Data::allocate(aalloc, options);
        do { if (!(x)) qBadAlloc(); } while (false);
        

        ((x->ref.isSharable() || options.testFlag(QArrayData::Unsharable)) ? static_cast<void>(0) : qt_assert("x->ref.isSharable() || options.testFlag(QArrayData::Unsharable)", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 703));
#line 705 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
        ((!x->ref.isStatic()) ? static_cast<void>(0) : qt_assert("!x->ref.isStatic()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 705));
        x->size = d->size;

        T *srcBegin = d->begin();
        T *srcEnd = d->end();
        T *dst = x->begin();

        if (!QTypeInfoQuery<T>::isRelocatable || (isShared && QTypeInfo<T>::isComplex)) {
            try {
                if (isShared || !std::is_nothrow_move_constructible<T>::value) {
                    
                    while (srcBegin != srcEnd)
                        new (dst++) T(*srcBegin++);
                } else {
                    while (srcBegin != srcEnd)
                        new (dst++) T(std::move(*srcBegin++));
                }
            } catch (...) {
                
                destruct(x->begin(), dst);
                throw;
            }
        } else {
            ::memcpy(static_cast<void *>(dst), static_cast<void *>(srcBegin), (srcEnd - srcBegin) * sizeof(T));
            dst += srcEnd - srcBegin;
        }

    } catch (...) {
        Data::deallocate(x);
        throw;
    }
    x->capacityReserved = d->capacityReserved;

    ((d != x) ? static_cast<void>(0) : qt_assert("d != x", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 738));
    if (!d->ref.deref()) {
        if (!QTypeInfoQuery<T>::isRelocatable || !aalloc || (isShared && QTypeInfo<T>::isComplex)) {
            
            
            freeData(d);
        } else {
            Data::deallocate(d);
        }
    }
    d = x;

    ((d->data()) ? static_cast<void>(0) : qt_assert("d->data()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 750));
    ((uint(d->size) <= d->alloc) ? static_cast<void>(0) : qt_assert("uint(d->size) <= d->alloc", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 751));

    ((d != Data::unsharableEmpty()) ? static_cast<void>(0) : qt_assert("d != Data::unsharableEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 753));
#line 755 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
    ((d != Data::sharedNull()) ? static_cast<void>(0) : qt_assert("d != Data::sharedNull()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 755));
    ((d->alloc >= uint(aalloc)) ? static_cast<void>(0) : qt_assert("d->alloc >= uint(aalloc)", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 756));
}


__pragma(warning(pop))
#line 762 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

template<typename T>
inline T QVector<T>::value(int i) const
{
    if (uint(i) >= uint(d->size)) {
        return T();
    }
    return d->begin()[i];
}
template<typename T>
inline T QVector<T>::value(int i, const T &defaultValue) const
{
    return uint(i) >= uint(d->size) ? defaultValue : d->begin()[i];
}

template <typename T>
void QVector<T>::append(const T &t)
{
    const bool isTooSmall = uint(d->size + 1) > d->alloc;
    if (!isDetached() || isTooSmall) {
        T copy(t);
        QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
        realloc(isTooSmall ? d->size + 1 : d->alloc, opt);

        if (QTypeInfo<T>::isComplex)
            new (d->end()) T(std::move(copy));
        else
            *d->end() = std::move(copy);

    } else {
        if (QTypeInfo<T>::isComplex)
            new (d->end()) T(t);
        else
            *d->end() = t;
    }
    ++d->size;
}

template <typename T>
void QVector<T>::append(T &&t)
{
    const bool isTooSmall = uint(d->size + 1) > d->alloc;
    if (!isDetached() || isTooSmall) {
        QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
        realloc(isTooSmall ? d->size + 1 : d->alloc, opt);
    }

    new (d->end()) T(std::move(t));

    ++d->size;
}

template <typename T>
void QVector<T>::removeLast()
{
    ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 817));
    ((d->alloc) ? static_cast<void>(0) : qt_assert("d->alloc", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 818));

    if (d->ref.isShared())
        detach();
    --d->size;
    if (QTypeInfo<T>::isComplex)
        (d->data() + d->size)->~T();
}

template <typename T>
typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
{
    ((isValidIterator(before)) ? static_cast<void>(0) : qt_assert_x("QVector::insert", "The specified iterator argument 'before' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 830));

    const auto offset = std::distance(d->begin(), before);
    if (n != 0) {
        const T copy(t);
        if (!isDetached() || d->size + n > int(d->alloc))
            realloc(d->size + n, QArrayData::Grow);
        if (!QTypeInfoQuery<T>::isRelocatable) {
            T *const e = d->end();
            T *const b = d->begin() + offset;

            T *i = e;
            T *j = i + n;

            
            while (i != b && j > e)
                new (--j) T(std::move(*--i));
            
            while (i != b)
                *--j = std::move(*--i);

            
            while (j != b && j > e)
                new (--j) T(copy);
            
            while (j != b)
                *--j = copy;
        } else {
            T *b = d->begin() + offset;
            T *i = b + n;
            memmove(static_cast<void *>(i), static_cast<const void *>(b), (d->size - offset) * sizeof(T));
            while (i != b)
                new (--i) T(copy);
        }
        d->size += n;
    }
    return d->begin() + offset;
}

template <typename T>
typename QVector<T>::iterator QVector<T>::insert(iterator before, T &&t)
{
    ((isValidIterator(before)) ? static_cast<void>(0) : qt_assert_x("QVector::insert", "The specified iterator argument 'before' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 872));

    const auto offset = std::distance(d->begin(), before);
    if (!isDetached() || d->size + 1 > int(d->alloc))
        realloc(d->size + 1, QArrayData::Grow);
    if (!QTypeInfoQuery<T>::isRelocatable) {
        T *i = d->end();
        T *j = i + 1;
        T *b = d->begin() + offset;
        
        if (i != b) {
            new (--j) T(std::move(*--i));
            while (i != b)
                *--j = std::move(*--i);
            *b = std::move(t);
        } else {
            new (b) T(std::move(t));
        }
    } else {
        T *b = d->begin() + offset;
        memmove(static_cast<void *>(b + 1), static_cast<const void *>(b), (d->size - offset) * sizeof(T));
        new (b) T(std::move(t));
    }
    d->size += 1;
    return d->begin() + offset;
}

template <typename T>
typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
{
    ((isValidIterator(abegin)) ? static_cast<void>(0) : qt_assert_x("QVector::erase", "The specified iterator argument 'abegin' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 902));
    ((isValidIterator(aend)) ? static_cast<void>(0) : qt_assert_x("QVector::erase", "The specified iterator argument 'aend' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 903));

    const auto itemsToErase = aend - abegin;

    if (!itemsToErase)
        return abegin;

    ((abegin >= d->begin()) ? static_cast<void>(0) : qt_assert("abegin >= d->begin()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 910));
    ((aend <= d->end()) ? static_cast<void>(0) : qt_assert("aend <= d->end()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 911));
    ((abegin <= aend) ? static_cast<void>(0) : qt_assert("abegin <= aend", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 912));

    const auto itemsUntouched = abegin - d->begin();

    
    
    
    if (d->alloc) {
        detach();
        abegin = d->begin() + itemsUntouched;
        aend = abegin + itemsToErase;
        if (!QTypeInfoQuery<T>::isRelocatable) {
            iterator moveBegin = abegin + itemsToErase;
            iterator moveEnd = d->end();
            while (moveBegin != moveEnd) {
                if (QTypeInfo<T>::isComplex)
                    static_cast<T *>(abegin)->~T();
                new (abegin++) T(*moveBegin++);
            }
            if (abegin < d->end()) {
                
                destruct(abegin, d->end());
            }
        } else {
            destruct(abegin, aend);
            
            
            
            memmove(static_cast<void *>(abegin), static_cast<void *>(aend),
                    (d->size - itemsToErase - itemsUntouched) * sizeof(T));
        }
        d->size -= int(itemsToErase);
    }
    return d->begin() + itemsUntouched;
}

template <typename T>
bool QVector<T>::operator==(const QVector<T> &v) const
{
    if (d == v.d)
        return true;
    if (d->size != v.d->size)
        return false;
    const T *vb = v.d->begin();
    const T *b  = d->begin();
    const T *e  = d->end();
    return std::equal(b, e, stdext::make_checked_array_iterator(vb, size_t(v.d->size)));
}

template <typename T>
QVector<T> &QVector<T>::fill(const T &from, int asize)
{
    const T copy(from);
    resize(asize < 0 ? d->size : asize);
    if (d->size) {
        T *i = d->end();
        T *b = d->begin();
        while (i != b)
            *--i = copy;
    }
    return *this;
}

template <typename T>
QVector<T> &QVector<T>::operator+=(const QVector &l)
{
    if (d->size == 0) {
        *this = l;
    } else {
        uint newSize = d->size + l.d->size;
        const bool isTooSmall = newSize > d->alloc;
        if (!isDetached() || isTooSmall) {
            QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
            realloc(isTooSmall ? newSize : d->alloc, opt);
        }

        if (d->alloc) {
            T *w = d->begin() + newSize;
            T *i = l.d->end();
            T *b = l.d->begin();
            while (i != b) {
                if (QTypeInfo<T>::isComplex)
                    new (--w) T(*--i);
                else
                    *--w = *--i;
            }
            d->size = newSize;
        }
    }
    return *this;
}

template <typename T>
int QVector<T>::indexOf(const T &t, int from) const
{
    if (from < 0)
        from = qMax(from + d->size, 0);
    if (from < d->size) {
        T* n = d->begin() + from - 1;
        T* e = d->end();
        while (++n != e)
            if (*n == t)
                return n - d->begin();
    }
    return -1;
}

template <typename T>
int QVector<T>::lastIndexOf(const T &t, int from) const
{
    if (from < 0)
        from += d->size;
    else if (from >= d->size)
        from = d->size-1;
    if (from >= 0) {
        T* b = d->begin();
        T* n = d->begin() + from + 1;
        while (n != b) {
            if (*--n == t)
                return n - b;
        }
    }
    return -1;
}

template <typename T>
bool QVector<T>::contains(const T &t) const
{
    const T *b = d->begin();
    const T *e = d->end();
    return std::find(b, e, t) != e;
}

template <typename T>
int QVector<T>::count(const T &t) const
{
    const T *b = d->begin();
    const T *e = d->end();
    return int(std::count(b, e, t));
}

template <typename T>
inline QVector<T> QVector<T>::mid(int pos, int len) const
{
    using namespace QtPrivate;
    switch (QContainerImplHelper::mid(d->size, &pos, &len)) {
    case QContainerImplHelper::Null:
    case QContainerImplHelper::Empty:
        return QVector<T>();
    case QContainerImplHelper::Full:
        return *this;
    case QContainerImplHelper::Subset:
        break;
    }

    QVector<T> midResult;
    midResult.realloc(len);
    T *srcFrom = d->begin() + pos;
    T *srcTo = d->begin() + pos + len;
    midResult.copyConstruct(srcFrom, srcTo, midResult.data());
    midResult.d->size = len;
    return midResult;
}

template <class T> class QVectorIterator { typedef typename QVector<T>::const_iterator const_iterator; QVector<T> c; const_iterator i; public: inline QVectorIterator(const QVector<T> &container) : c(container), i(c.constBegin()) {} inline QVectorIterator &operator=(const QVector<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
template <class T> class QMutableVectorIterator { typedef typename QVector<T>::iterator iterator; typedef typename QVector<T>::const_iterator const_iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableVectorIterator(QVector<T> &container) : c(&container) { i = c->begin(); n = c->end(); } inline QMutableVectorIterator &operator=(QVector<T> &container) { c = &container; i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 1077)); return *n; } inline const T &value() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h", 1077)); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };

template <typename T>
uint qHash(const QVector<T> &key, uint seed = 0)
    noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
{
    return qHashRange(key.cbegin(), key.cend(), seed);
}

template <typename T>
bool operator<(const QVector<T> &lhs, const QVector<T> &rhs)
    noexcept(noexcept(std::lexicographical_compare(lhs.begin(), lhs.end(),
                                                               rhs.begin(), rhs.end())))
{
    return std::lexicographical_compare(lhs.begin(), lhs.end(),
                                        rhs.begin(), rhs.end());
}

template <typename T>
inline bool operator>(const QVector<T> &lhs, const QVector<T> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return rhs < lhs;
}

template <typename T>
inline bool operator<=(const QVector<T> &lhs, const QVector<T> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return !(lhs > rhs);
}

template <typename T>
inline bool operator>=(const QVector<T> &lhs, const QVector<T> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return !(lhs < rhs);
}










#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"














































#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"




class __declspec(dllimport) QPoint
{
public:
    constexpr QPoint();
    constexpr QPoint(int xpos, int ypos);

    constexpr inline bool isNull() const;

    constexpr inline int x() const;
    constexpr inline int y() const;
    constexpr inline void setX(int x);
    constexpr inline void setY(int y);

    constexpr inline int manhattanLength() const;

    constexpr QPoint transposed() const noexcept { return {yp, xp}; }

    constexpr inline int &rx();
    constexpr inline int &ry();

    constexpr inline QPoint &operator+=(const QPoint &p);
    constexpr inline QPoint &operator-=(const QPoint &p);

    constexpr inline QPoint &operator*=(float factor);
    constexpr inline QPoint &operator*=(double factor);
    constexpr inline QPoint &operator*=(int factor);

    constexpr inline QPoint &operator/=(qreal divisor);

    constexpr static inline int dotProduct(const QPoint &p1, const QPoint &p2)
    { return p1.xp * p2.xp + p1.yp * p2.yp; }

    friend constexpr inline bool operator==(const QPoint &, const QPoint &);
    friend constexpr inline bool operator!=(const QPoint &, const QPoint &);
    friend constexpr inline const QPoint operator+(const QPoint &, const QPoint &);
    friend constexpr inline const QPoint operator-(const QPoint &, const QPoint &);
    friend constexpr inline const QPoint operator*(const QPoint &, float);
    friend constexpr inline const QPoint operator*(float, const QPoint &);
    friend constexpr inline const QPoint operator*(const QPoint &, double);
    friend constexpr inline const QPoint operator*(double, const QPoint &);
    friend constexpr inline const QPoint operator*(const QPoint &, int);
    friend constexpr inline const QPoint operator*(int, const QPoint &);
    friend constexpr inline const QPoint operator+(const QPoint &);
    friend constexpr inline const QPoint operator-(const QPoint &);
    friend constexpr inline const QPoint operator/(const QPoint &, qreal);



#line 101 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"

private:
    friend class QTransform;
    int xp;
    int yp;
};

template<> class QTypeInfo<QPoint > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QPoint>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QPoint>(), isLarge = (sizeof(QPoint)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QPoint >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QPoint) }; static inline const char *name() { return "QPoint"; } };





__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QPoint &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QPoint &);
#line 117 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"





constexpr inline QPoint::QPoint() : xp(0), yp(0) {}

constexpr inline QPoint::QPoint(int xpos, int ypos) : xp(xpos), yp(ypos) {}

constexpr inline bool QPoint::isNull() const
{ return xp == 0 && yp == 0; }

constexpr inline int QPoint::x() const
{ return xp; }

constexpr inline int QPoint::y() const
{ return yp; }

constexpr inline void QPoint::setX(int xpos)
{ xp = xpos; }

constexpr inline void QPoint::setY(int ypos)
{ yp = ypos; }

inline int constexpr QPoint::manhattanLength() const
{ return qAbs(x())+qAbs(y()); }

constexpr inline int &QPoint::rx()
{ return xp; }

constexpr inline int &QPoint::ry()
{ return yp; }

constexpr inline QPoint &QPoint::operator+=(const QPoint &p)
{ xp+=p.xp; yp+=p.yp; return *this; }

constexpr inline QPoint &QPoint::operator-=(const QPoint &p)
{ xp-=p.xp; yp-=p.yp; return *this; }

constexpr inline QPoint &QPoint::operator*=(float factor)
{ xp = qRound(xp*factor); yp = qRound(yp*factor); return *this; }

constexpr inline QPoint &QPoint::operator*=(double factor)
{ xp = qRound(xp*factor); yp = qRound(yp*factor); return *this; }

constexpr inline QPoint &QPoint::operator*=(int factor)
{ xp = xp*factor; yp = yp*factor; return *this; }

constexpr inline bool operator==(const QPoint &p1, const QPoint &p2)
{ return p1.xp == p2.xp && p1.yp == p2.yp; }

constexpr inline bool operator!=(const QPoint &p1, const QPoint &p2)
{ return p1.xp != p2.xp || p1.yp != p2.yp; }

constexpr inline const QPoint operator+(const QPoint &p1, const QPoint &p2)
{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); }

constexpr inline const QPoint operator-(const QPoint &p1, const QPoint &p2)
{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); }

constexpr inline const QPoint operator*(const QPoint &p, float factor)
{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }

constexpr inline const QPoint operator*(const QPoint &p, double factor)
{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }

constexpr inline const QPoint operator*(const QPoint &p, int factor)
{ return QPoint(p.xp*factor, p.yp*factor); }

constexpr inline const QPoint operator*(float factor, const QPoint &p)
{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }

constexpr inline const QPoint operator*(double factor, const QPoint &p)
{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }

constexpr inline const QPoint operator*(int factor, const QPoint &p)
{ return QPoint(p.xp*factor, p.yp*factor); }

constexpr inline const QPoint operator+(const QPoint &p)
{ return p; }

constexpr inline const QPoint operator-(const QPoint &p)
{ return QPoint(-p.xp, -p.yp); }

constexpr inline QPoint &QPoint::operator/=(qreal c)
{
    xp = qRound(xp/c);
    yp = qRound(yp/c);
    return *this;
}

constexpr inline const QPoint operator/(const QPoint &p, qreal c)
{
    return QPoint(qRound(p.xp/c), qRound(p.yp/c));
}


__declspec(dllimport) QDebug operator<<(QDebug, const QPoint &);
#line 216 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"





class __declspec(dllimport) QPointF
{
public:
    constexpr QPointF();
    constexpr QPointF(const QPoint &p);
    constexpr QPointF(qreal xpos, qreal ypos);

    constexpr inline qreal manhattanLength() const;

    inline bool isNull() const;

    constexpr inline qreal x() const;
    constexpr inline qreal y() const;
    constexpr inline void setX(qreal x);
    constexpr inline void setY(qreal y);

    constexpr QPointF transposed() const noexcept { return {yp, xp}; }

    constexpr inline qreal &rx();
    constexpr inline qreal &ry();

    constexpr inline QPointF &operator+=(const QPointF &p);
    constexpr inline QPointF &operator-=(const QPointF &p);
    constexpr inline QPointF &operator*=(qreal c);
    constexpr inline QPointF &operator/=(qreal c);

    constexpr static inline qreal dotProduct(const QPointF &p1, const QPointF &p2)
    { return p1.xp * p2.xp + p1.yp * p2.yp; }

    friend constexpr inline bool operator==(const QPointF &, const QPointF &);
    friend constexpr inline bool operator!=(const QPointF &, const QPointF &);
    friend constexpr inline const QPointF operator+(const QPointF &, const QPointF &);
    friend constexpr inline const QPointF operator-(const QPointF &, const QPointF &);
    friend constexpr inline const QPointF operator*(qreal, const QPointF &);
    friend constexpr inline const QPointF operator*(const QPointF &, qreal);
    friend constexpr inline const QPointF operator+(const QPointF &);
    friend constexpr inline const QPointF operator-(const QPointF &);
    friend constexpr inline const QPointF operator/(const QPointF &, qreal);

    constexpr QPoint toPoint() const;




#line 266 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"

private:
    friend class QMatrix;
    friend class QTransform;

    qreal xp;
    qreal yp;
};

template<> class QTypeInfo<QPointF > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QPointF>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QPointF>(), isLarge = (sizeof(QPointF)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QPointF >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QPointF) }; static inline const char *name() { return "QPointF"; } };





__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QPointF &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QPointF &);
#line 284 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"





constexpr inline QPointF::QPointF() : xp(0), yp(0) { }

constexpr inline QPointF::QPointF(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) { }

constexpr inline QPointF::QPointF(const QPoint &p) : xp(p.x()), yp(p.y()) { }

constexpr inline qreal QPointF::manhattanLength() const
{
    return qAbs(x())+qAbs(y());
}

inline bool QPointF::isNull() const
{
    return qIsNull(xp) && qIsNull(yp);
}

constexpr inline qreal QPointF::x() const
{
    return xp;
}

constexpr inline qreal QPointF::y() const
{
    return yp;
}

constexpr inline void QPointF::setX(qreal xpos)
{
    xp = xpos;
}

constexpr inline void QPointF::setY(qreal ypos)
{
    yp = ypos;
}

constexpr inline qreal &QPointF::rx()
{
    return xp;
}

constexpr inline qreal &QPointF::ry()
{
    return yp;
}

constexpr inline QPointF &QPointF::operator+=(const QPointF &p)
{
    xp+=p.xp;
    yp+=p.yp;
    return *this;
}

constexpr inline QPointF &QPointF::operator-=(const QPointF &p)
{
    xp-=p.xp; yp-=p.yp; return *this;
}

constexpr inline QPointF &QPointF::operator*=(qreal c)
{
    xp*=c; yp*=c; return *this;
}

__pragma(warning(push))




constexpr inline bool operator==(const QPointF &p1, const QPointF &p2)
{
    return ((!p1.xp || !p2.xp) ? qFuzzyIsNull(p1.xp - p2.xp) : qFuzzyCompare(p1.xp, p2.xp))
        && ((!p1.yp || !p2.yp) ? qFuzzyIsNull(p1.yp - p2.yp) : qFuzzyCompare(p1.yp, p2.yp));
}

constexpr inline bool operator!=(const QPointF &p1, const QPointF &p2)
{
    return !(p1 == p2);
}

__pragma(warning(pop))

constexpr inline const QPointF operator+(const QPointF &p1, const QPointF &p2)
{
    return QPointF(p1.xp+p2.xp, p1.yp+p2.yp);
}

constexpr inline const QPointF operator-(const QPointF &p1, const QPointF &p2)
{
    return QPointF(p1.xp-p2.xp, p1.yp-p2.yp);
}

constexpr inline const QPointF operator*(const QPointF &p, qreal c)
{
    return QPointF(p.xp*c, p.yp*c);
}

constexpr inline const QPointF operator*(qreal c, const QPointF &p)
{
    return QPointF(p.xp*c, p.yp*c);
}

constexpr inline const QPointF operator+(const QPointF &p)
{
    return p;
}

constexpr inline const QPointF operator-(const QPointF &p)
{
    return QPointF(-p.xp, -p.yp);
}

constexpr inline QPointF &QPointF::operator/=(qreal divisor)
{
    xp/=divisor;
    yp/=divisor;
    return *this;
}

constexpr inline const QPointF operator/(const QPointF &p, qreal divisor)
{
    return QPointF(p.xp/divisor, p.yp/divisor);
}

constexpr inline QPoint QPointF::toPoint() const
{
    return QPoint(qRound(xp), qRound(yp));
}


__declspec(dllimport) QDebug operator<<(QDebug d, const QPointF &p);
#line 420 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"



#line 424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qpoint.h"
#pragma external_header(pop)
#line 1126 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

extern template class __declspec(dllimport) QVector<QPointF>;
extern template class __declspec(dllimport) QVector<QPoint>;
#line 1130 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"

QVector<uint> QStringView::toUcs4() const { return QtPrivate::convertToUcs4(*this); }



#line 1136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvector.h"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"











































#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"
























































































#pragma external_header(pop)
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"






#line 57 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"







#pragma warning( push )
#pragma warning( disable : 4127 ) 
#line 67 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"




template <typename T> class QVector;
template <typename T> class QSet;

template <typename T> struct QListSpecialMethods
{
protected:
    ~QListSpecialMethods() = default;
};
template <> struct QListSpecialMethods<QByteArray>;
template <> struct QListSpecialMethods<QString>;

struct __declspec(dllimport) QListData {
    
    
    struct NotArrayCompatibleLayout {};
    struct NotIndirectLayout {};
    struct ArrayCompatibleLayout   : NotIndirectLayout {};                           
    struct InlineWithPaddingLayout : NotArrayCompatibleLayout, NotIndirectLayout {}; 
    struct IndirectLayout          : NotArrayCompatibleLayout {};                    

    struct Data {
        QtPrivate::RefCount ref;
        int alloc, begin, end;
        void *array[1];
    };
    enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };

    Data *detach(int alloc);
    Data *detach_grow(int *i, int n);
    void realloc(int alloc);
    void realloc_grow(int growth);
    inline void dispose() { dispose(d); }
    static void dispose(Data *d);
    static const Data shared_null;
    Data *d;
    void **erase(void **xi);
    void **append(int n);
    void **append();
    void **append(const QListData &l);
    void **prepend();
    void **insert(int i);
    void remove(int i);
    void remove(int i, int n);
    void move(int from, int to);
    inline int size() const noexcept { return int(d->end - d->begin); }   
    inline bool isEmpty() const noexcept { return d->end  == d->begin; }
    inline void **at(int i) const noexcept { return d->array + d->begin + i; }
    inline void **begin() const noexcept { return d->array + d->begin; }
    inline void **end() const noexcept { return d->array + d->end; }
};

namespace QtPrivate {
    template <typename V, typename U> int indexOf(const QList<V> &list, const U &u, int from);
    template <typename V, typename U> int lastIndexOf(const QList<V> &list, const U &u, int from);
}

template <typename T>
class QList

    : public QListSpecialMethods<T>
#line 132 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
{
public:
    struct MemoryLayout
        : std::conditional<
            
            QTypeInfo<T>::isStatic || QTypeInfo<T>::isLarge,
            QListData::IndirectLayout,
            typename std::conditional<
                sizeof(T) == sizeof(void*),
                QListData::ArrayCompatibleLayout,
                QListData::InlineWithPaddingLayout
             >::type>::type {};
private:
    template <typename V, typename U> friend int QtPrivate::indexOf(const QList<V> &list, const U &u, int from);
    template <typename V, typename U> friend int QtPrivate::lastIndexOf(const QList<V> &list, const U &u, int from);
    struct Node { void *v;


#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
        inline T &t()
        { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
                                       ? v : this); }
#line 155 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    };

    union { QListData p; QListData::Data *d; };

public:
    inline QList() noexcept : d(const_cast<QListData::Data *>(&QListData::shared_null)) { }
    QList(const QList<T> &l);
    ~QList();
    QList<T> &operator=(const QList<T> &l);
    inline QList(QList<T> &&other) noexcept
        : d(other.d) { other.d = const_cast<QListData::Data *>(&QListData::shared_null); }
    inline QList &operator=(QList<T> &&other) noexcept
    { QList moved(std::move(other)); swap(moved); return *this; }
    inline void swap(QList<T> &other) noexcept { qSwap(d, other.d); }
    inline QList(std::initializer_list<T> args)
        : QList(args.begin(), args.end()) {}
    template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
    QList(InputIterator first, InputIterator last);
    bool operator==(const QList<T> &l) const;
    inline bool operator!=(const QList<T> &l) const { return !(*this == l); }

    inline int size() const noexcept { return p.size(); }

    inline void detach() { if (d->ref.isShared()) detach_helper(); }

    inline void detachShared()
    {
        
        if (d->ref.isShared() && this->d != &QListData::shared_null)
            detach_helper();
    }

    inline bool isDetached() const { return !d->ref.isShared(); }

    inline void setSharable(bool sharable)
    {
        if (sharable == d->ref.isSharable())
            return;
        if (!sharable)
            detach();
        if (d != &QListData::shared_null)
            d->ref.setSharable(sharable);
    }
#line 199 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    inline bool isSharedWith(const QList<T> &other) const noexcept { return d == other.d; }

    inline bool isEmpty() const noexcept { return p.isEmpty(); }

    void clear();

    const T &at(int i) const;
    const T &operator[](int i) const;
    T &operator[](int i);

    void reserve(int size);
    void append(const T &t);
    void append(const QList<T> &t);
    void prepend(const T &t);
    void insert(int i, const T &t);
    void replace(int i, const T &t);
    void removeAt(int i);
    int removeAll(const T &t);
    bool removeOne(const T &t);
    T takeAt(int i);
    T takeFirst();
    T takeLast();
    void move(int from, int to);
    void swapItemsAt(int i, int j);



#line 227 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    int indexOf(const T &t, int from = 0) const;
    int lastIndexOf(const T &t, int from = -1) const;
    bool contains(const T &t) const;
    int count(const T &t) const;

    class const_iterator;

    class iterator {
    public:
        Node *i;
        typedef std::random_access_iterator_tag  iterator_category;
        
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline iterator() noexcept : i(nullptr) {}
        inline iterator(Node *n) noexcept : i(n) {}

        
        
        inline iterator(const iterator &o) noexcept : i(o.i){}
        inline iterator &operator=(const iterator &o) noexcept
        { i = o.i; return *this; }
#line 253 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
        inline T &operator*() const { return i->t(); }
        inline T *operator->() const { return &i->t(); }
        inline T &operator[](difference_type j) const { return i[j].t(); }
        inline bool operator==(const iterator &o) const noexcept { return i == o.i; }
        inline bool operator!=(const iterator &o) const noexcept { return i != o.i; }
        inline bool operator<(const iterator& other) const noexcept { return i < other.i; }
        inline bool operator<=(const iterator& other) const noexcept { return i <= other.i; }
        inline bool operator>(const iterator& other) const noexcept { return i > other.i; }
        inline bool operator>=(const iterator& other) const noexcept { return i >= other.i; }














        inline iterator &operator++() { ++i; return *this; }
        inline iterator operator++(int) { Node *n = i; ++i; return n; }
        inline iterator &operator--() { i--; return *this; }
        inline iterator operator--(int) { Node *n = i; i--; return n; }
        inline iterator &operator+=(difference_type j) { i+=j; return *this; }
        inline iterator &operator-=(difference_type j) { i-=j; return *this; }
        inline iterator operator+(difference_type j) const { return iterator(i+j); }
        inline iterator operator-(difference_type j) const { return iterator(i-j); }
        friend inline iterator operator+(difference_type j, iterator k) { return k + j; }
        inline int operator-(iterator j) const { return int(i - j.i); }
    };
    friend class iterator;

    class const_iterator {
    public:
        Node *i;
        typedef std::random_access_iterator_tag  iterator_category;
        
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline const_iterator() noexcept : i(nullptr) {}
        inline const_iterator(Node *n) noexcept : i(n) {}

        
        
        inline const_iterator(const const_iterator &o) noexcept : i(o.i) {}
        inline const_iterator &operator=(const const_iterator &o) noexcept
        { i = o.i; return *this; }
#line 308 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"

        inline explicit const_iterator(const iterator &o) noexcept : i(o.i) {}


#line 313 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
        inline const T &operator*() const { return i->t(); }
        inline const T *operator->() const { return &i->t(); }
        inline const T &operator[](difference_type j) const { return i[j].t(); }
        inline bool operator==(const const_iterator &o) const noexcept { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const noexcept { return i != o.i; }
        inline bool operator<(const const_iterator& other) const noexcept { return i < other.i; }
        inline bool operator<=(const const_iterator& other) const noexcept { return i <= other.i; }
        inline bool operator>(const const_iterator& other) const noexcept { return i > other.i; }
        inline bool operator>=(const const_iterator& other) const noexcept { return i >= other.i; }
        inline const_iterator &operator++() { ++i; return *this; }
        inline const_iterator operator++(int) { Node *n = i; ++i; return n; }
        inline const_iterator &operator--() { i--; return *this; }
        inline const_iterator operator--(int) { Node *n = i; i--; return n; }
        inline const_iterator &operator+=(difference_type j) { i+=j; return *this; }
        inline const_iterator &operator-=(difference_type j) { i-=j; return *this; }
        inline const_iterator operator+(difference_type j) const { return const_iterator(i+j); }
        inline const_iterator operator-(difference_type j) const { return const_iterator(i-j); }
        friend inline const_iterator operator+(difference_type j, const_iterator k) { return k + j; }
        inline int operator-(const_iterator j) const { return int(i - j.i); }
    };
    friend class const_iterator;

    
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator begin() const noexcept { return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator cbegin() const noexcept { return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator constBegin() const noexcept { return reinterpret_cast<Node *>(p.begin()); }
    inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator end() const noexcept { return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator cend() const noexcept { return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator constEnd() const noexcept { return reinterpret_cast<Node *>(p.end()); }
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
    iterator insert(iterator before, const T &t);
    iterator erase(iterator pos);
    iterator erase(iterator first, iterator last);

    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return p.size(); }
    inline int length() const { return p.size(); } 
    inline T& first() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 361)); return *begin(); }
    inline const T& constFirst() const { return first(); }
    inline const T& first() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 363)); return at(0); }
    T& last() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 364)); return *(--end()); }
    const T& last() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 365)); return at(count() - 1); }
    inline const T& constLast() const { return last(); }
    inline void removeFirst() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 367)); erase(begin()); }
    inline void removeLast() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 368)); erase(--end()); }
    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
    QList<T> mid(int pos, int length = -1) const;

    T value(int i) const;
    T value(int i, const T &defaultValue) const;

    
    inline void push_back(const T &t) { append(t); }
    inline void push_front(const T &t) { prepend(t); }
    inline T& front() { return first(); }
    inline const T& front() const { return first(); }
    inline T& back() { return last(); }
    inline const T& back() const { return last(); }
    inline void pop_front() { removeFirst(); }
    inline void pop_back() { removeLast(); }
    inline bool empty() const { return isEmpty(); }
    typedef int size_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    
    typedef qptrdiff difference_type;

    
    QList<T> &operator+=(const QList<T> &l);
    inline QList<T> operator+(const QList<T> &l) const
    { QList n = *this; n += l; return n; }
    inline QList<T> &operator+=(const T &t)
    { append(t); return *this; }
    inline QList<T> &operator<< (const T &t)
    { append(t); return *this; }
    inline QList<T> &operator<<(const QList<T> &l)
    { *this += l; return *this; }

    static QList<T> fromVector(const QVector<T> &vector);
    QVector<T> toVector() const;













#line 422 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"

private:
    Node *detach_helper_grow(int i, int n);
    void detach_helper(int alloc);
    void detach_helper();
    void dealloc(QListData::Data *d);

    void node_construct(Node *n, const T &t);
    void node_destruct(Node *n);
    void node_copy(Node *from, Node *to, Node *src);
    void node_destruct(Node *from, Node *to);

    bool isValidIterator(const iterator &i) const noexcept
    {
        const std::less<const Node *> less = {};
        return !less(i.i, cbegin().i) && !less(cend().i, i.i);
    }

private:
    inline bool op_eq_impl(const QList &other, QListData::NotArrayCompatibleLayout) const;
    inline bool op_eq_impl(const QList &other, QListData::ArrayCompatibleLayout) const;
    inline bool contains_impl(const T &, QListData::NotArrayCompatibleLayout) const;
    inline bool contains_impl(const T &, QListData::ArrayCompatibleLayout) const;
    inline int count_impl(const T &, QListData::NotArrayCompatibleLayout) const;
    inline int count_impl(const T &, QListData::ArrayCompatibleLayout) const;
};


template <typename InputIterator,
          typename ValueType = typename std::iterator_traits<InputIterator>::value_type,
          QtPrivate::IfIsInputIterator<InputIterator> = true>
QList(InputIterator, InputIterator) -> QList<ValueType>;
#line 455 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"





#line 461 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"

template <typename T>
inline void QList<T>::node_construct(Node *n, const T &t)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
    else if (QTypeInfo<T>::isComplex) new (n) T(t);





#line 473 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    
    else ::memcpy(n, static_cast<const void *>(&t), sizeof(T));
#line 476 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
}

template <typename T>
inline void QList<T>::node_destruct(Node *n)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
    else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
}

template <typename T>
inline void QList<T>::node_copy(Node *from, Node *to, Node *src)
{
    Node *current = from;
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        try {
            while(current != to) {
                current->v = new T(*reinterpret_cast<T*>(src->v));
                ++current;
                ++src;
            }
        } catch (...) {
            while (current-- != from)
                delete reinterpret_cast<T*>(current->v);
            throw;
        }

    } else if (QTypeInfo<T>::isComplex) {
        try {
            while(current != to) {
                new (current) T(*reinterpret_cast<T*>(src));
                ++current;
                ++src;
            }
        } catch (...) {
            while (current-- != from)
                (reinterpret_cast<T*>(current))->~T();
            throw;
        }
    } else {
        if (src != from && to - from > 0)
            memcpy(from, src, (to - from) * sizeof(Node));
    }
}

template <typename T>
inline void QList<T>::node_destruct(Node *from, Node *to)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
        while(from != to) --to, delete reinterpret_cast<T*>(to->v);
    else if (QTypeInfo<T>::isComplex)
        while (from != to) --to, reinterpret_cast<T*>(to)->~T();
}

template <typename T>
inline QList<T> &QList<T>::operator=(const QList<T> &l)
{
    if (d != l.d) {
        QList<T> tmp(l);
        tmp.swap(*this);
    }
    return *this;
}
template <typename T>
inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
{
    ((isValidIterator(before)) ? static_cast<void>(0) : qt_assert_x("QList::insert", "The specified iterator argument 'before' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 541));

    int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
    Node *n = nullptr;
    if (d->ref.isShared())
        n = detach_helper_grow(iBefore, 1);
    else
        n = reinterpret_cast<Node *>(p.insert(iBefore));
    try {
        node_construct(n, t);
    } catch (...) {
        p.remove(iBefore);
        throw;
    }
    return n;
}
template <typename T>
inline typename QList<T>::iterator QList<T>::erase(iterator it)
{
    ((isValidIterator(it)) ? static_cast<void>(0) : qt_assert_x("QList::erase", "The specified iterator argument 'it' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 560));
    if (d->ref.isShared()) {
        int offset = int(it.i - reinterpret_cast<Node *>(p.begin()));
        it = begin(); 
        it += offset;
    }
    node_destruct(it.i);
    return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i)));
}
template <typename T>
inline const T &QList<T>::at(int i) const
{ ((i >= 0 && i < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::at", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 571));
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline const T &QList<T>::operator[](int i) const
{ ((i >= 0 && i < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::operator[]", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 575));
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline T &QList<T>::operator[](int i)
{ ((i >= 0 && i < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::operator[]", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 579));
  detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline void QList<T>::removeAt(int i)
{

    ((i >= 0 && i < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::removeAt", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 585));
#line 587 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    if (i < 0 || i >= p.size()) {

        QMessageLogger(static_cast<const char *>("F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"), 589, static_cast<const char *>( __FUNCSIG__  )).warning("QList::removeAt(): Index out of range.");
#line 591 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
        return;
    }
    detach();
    node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i);
}
template <typename T>
inline T QList<T>::takeAt(int i)
{ ((i >= 0 && i < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::take", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 598));
 detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = std::move(n->t()); node_destruct(n);
 p.remove(i); return t; }
template <typename T>
inline T QList<T>::takeFirst()
{ T t = std::move(first()); removeFirst(); return t; }
template <typename T>
inline T QList<T>::takeLast()
{ T t = std::move(last()); removeLast(); return t; }

template <typename T>
inline void QList<T>::reserve(int alloc)
{
    if (d->alloc < alloc) {
        if (d->ref.isShared())
            detach_helper(alloc);
        else
            p.realloc(alloc);
    }
}

template <typename T>
inline void QList<T>::append(const T &t)
{
    if (d->ref.isShared()) {
        Node *n = detach_helper_grow(2147483647, 1);
        try {
            node_construct(n, t);
        } catch (...) {
            --d->end;
            throw;
        }
    } else {
        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
            Node *n = reinterpret_cast<Node *>(p.append());
            try {
                node_construct(n, t);
            } catch (...) {
                --d->end;
                throw;
            }
        } else {
            Node *n, copy;
            node_construct(&copy, t); 
            try {
                n = reinterpret_cast<Node *>(p.append());;
            } catch (...) {
                node_destruct(&copy);
                throw;
            }
            *n = copy;
        }
    }
}

template <typename T>
inline void QList<T>::prepend(const T &t)
{
    if (d->ref.isShared()) {
        Node *n = detach_helper_grow(0, 1);
        try {
            node_construct(n, t);
        } catch (...) {
            ++d->begin;
            throw;
        }
    } else {
        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
            Node *n = reinterpret_cast<Node *>(p.prepend());
            try {
                node_construct(n, t);
            } catch (...) {
                ++d->begin;
                throw;
            }
        } else {
            Node *n, copy;
            node_construct(&copy, t); 
            try {
                n = reinterpret_cast<Node *>(p.prepend());;
            } catch (...) {
                node_destruct(&copy);
                throw;
            }
            *n = copy;
        }
    }
}

template <typename T>
inline void QList<T>::insert(int i, const T &t)
{

    ((i >= 0 && i <= p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 691));



#line 696 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    if (d->ref.isShared()) {
        Node *n = detach_helper_grow(i, 1);
        try {
            node_construct(n, t);
        } catch (...) {
            p.remove(i);
            throw;
        }
    } else {
        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
            Node *n = reinterpret_cast<Node *>(p.insert(i));
            try {
                node_construct(n, t);
            } catch (...) {
                p.remove(i);
                throw;
            }
        } else {
            Node *n, copy;
            node_construct(&copy, t); 
            try {
                n = reinterpret_cast<Node *>(p.insert(i));;
            } catch (...) {
                node_destruct(&copy);
                throw;
            }
            *n = copy;
        }
    }
}

template <typename T>
inline void QList<T>::replace(int i, const T &t)
{
    ((i >= 0 && i < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::replace", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 730));
    detach();
    reinterpret_cast<Node *>(p.at(i))->t() = t;
}

template <typename T>
inline void QList<T>::swapItemsAt(int i, int j)
{
    ((i >= 0 && i < p.size() && j >= 0 && j < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::swap", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 739));
#line 740 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    detach();
    qSwap(d->array[d->begin + i], d->array[d->begin + j]);
}

template <typename T>
inline void QList<T>::move(int from, int to)
{
    ((from >= 0 && from < p.size() && to >= 0 && to < p.size()) ? static_cast<void>(0) : qt_assert_x("QList<T>::move", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 748));
#line 749 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
    detach();
    p.move(from, to);
}

template<typename T>
inline QList<T> QList<T>::mid(int pos, int alength) const
{
    using namespace QtPrivate;
    switch (QContainerImplHelper::mid(size(), &pos, &alength)) {
    case QContainerImplHelper::Null:
    case QContainerImplHelper::Empty:
        return QList<T>();
    case QContainerImplHelper::Full:
        return *this;
    case QContainerImplHelper::Subset:
        break;
    }

    QList<T> cpy;
    if (alength <= 0)
        return cpy;
    cpy.reserve(alength);
    cpy.d->end = alength;
    try {
        cpy.node_copy(reinterpret_cast<Node *>(cpy.p.begin()),
                      reinterpret_cast<Node *>(cpy.p.end()),
                      reinterpret_cast<Node *>(p.begin() + pos));
    } catch (...) {
        
        cpy.d->end = 0;
        throw;
    }
    return cpy;
}

template<typename T>
inline T QList<T>::value(int i) const
{
    if (i < 0 || i >= p.size()) {
        return T();
    }
    return reinterpret_cast<Node *>(p.at(i))->t();
}

template<typename T>
inline T QList<T>::value(int i, const T& defaultValue) const
{
    return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
}

template <typename T>
inline typename QList<T>::Node *QList<T>::detach_helper_grow(int i, int c)
{
    Node *n = reinterpret_cast<Node *>(p.begin());
    QListData::Data *x = p.detach_grow(&i, c);
    try {
        node_copy(reinterpret_cast<Node *>(p.begin()),
                  reinterpret_cast<Node *>(p.begin() + i), n);
    } catch (...) {
        p.dispose();
        d = x;
        throw;
    }
    try {
        node_copy(reinterpret_cast<Node *>(p.begin() + i + c),
                  reinterpret_cast<Node *>(p.end()), n + i);
    } catch (...) {
        node_destruct(reinterpret_cast<Node *>(p.begin()),
                      reinterpret_cast<Node *>(p.begin() + i));
        p.dispose();
        d = x;
        throw;
    }

    if (!x->ref.deref())
        dealloc(x);

    return reinterpret_cast<Node *>(p.begin() + i);
}

template <typename T>
inline void QList<T>::detach_helper(int alloc)
{
    Node *n = reinterpret_cast<Node *>(p.begin());
    QListData::Data *x = p.detach(alloc);
    try {
        node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
    } catch (...) {
        p.dispose();
        d = x;
        throw;
    }

    if (!x->ref.deref())
        dealloc(x);
}

template <typename T>
inline void QList<T>::detach_helper()
{
    detach_helper(d->alloc);
}

template <typename T>
inline QList<T>::QList(const QList<T> &l)
    : QListSpecialMethods<T>(l), d(l.d)
{
    if (!d->ref.ref()) {
        p.detach(d->alloc);

        try {
            node_copy(reinterpret_cast<Node *>(p.begin()),
                    reinterpret_cast<Node *>(p.end()),
                    reinterpret_cast<Node *>(l.p.begin()));
        } catch (...) {
            QListData::dispose(d);
            throw;
        }
    }
}

template <typename T>
inline QList<T>::~QList()
{
    if (!d->ref.deref())
        dealloc(d);
}

template <typename T>
template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator>>
QList<T>::QList(InputIterator first, InputIterator last)
    : QList()
{
    QtPrivate::reserveIfForwardIterator(this, first, last);
    std::copy(first, last, std::back_inserter(*this));
}

template <typename T>
inline bool QList<T>::operator==(const QList<T> &l) const
{
    if (d == l.d)
        return true;
    if (p.size() != l.p.size())
        return false;
    return this->op_eq_impl(l, MemoryLayout());
}

template <typename T>
inline bool QList<T>::op_eq_impl(const QList &l, QListData::NotArrayCompatibleLayout) const
{
    Node *i = reinterpret_cast<Node *>(p.begin());
    Node *e = reinterpret_cast<Node *>(p.end());
    Node *li = reinterpret_cast<Node *>(l.p.begin());
    for (; i != e; ++i, ++li) {
        if (!(i->t() == li->t()))
            return false;
    }
    return true;
}

template <typename T>
inline bool QList<T>::op_eq_impl(const QList &l, QListData::ArrayCompatibleLayout) const
{
    const T *lb = reinterpret_cast<const T*>(l.p.begin());
    const T *b  = reinterpret_cast<const T*>(p.begin());
    const T *e  = reinterpret_cast<const T*>(p.end());
    return std::equal(b, e, stdext::make_checked_array_iterator(lb, size_t(l.p.size())));
}

template <typename T>
inline void QList<T>::dealloc(QListData::Data *data)
{
    node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
                  reinterpret_cast<Node *>(data->array + data->end));
    QListData::dispose(data);
}


template <typename T>
inline void QList<T>::clear()
{
    *this = QList<T>();
}

template <typename T>
inline int QList<T>::removeAll(const T &_t)
{
    int index = indexOf(_t);
    if (index == -1)
        return 0;

    const T t = _t;
    detach();

    Node *i = reinterpret_cast<Node *>(p.at(index));
    Node *e = reinterpret_cast<Node *>(p.end());
    Node *n = i;
    node_destruct(i);
    while (++i != e) {
        if (i->t() == t)
            node_destruct(i);
        else
            *n++ = *i;
    }

    int removedCount = int(e - n);
    d->end -= removedCount;
    return removedCount;
}

template <typename T>
inline bool QList<T>::removeOne(const T &_t)
{
    int index = indexOf(_t);
    if (index != -1) {
        removeAt(index);
        return true;
    }
    return false;
}

template <typename T>
inline typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
                                                                 typename QList<T>::iterator alast)
{
    ((isValidIterator(afirst)) ? static_cast<void>(0) : qt_assert_x("QList::erase", "The specified iterator argument 'afirst' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 974));
    ((isValidIterator(alast)) ? static_cast<void>(0) : qt_assert_x("QList::erase", "The specified iterator argument 'alast' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 975));

    if (d->ref.isShared()) {
        
        int offsetfirst = int(afirst.i - reinterpret_cast<Node *>(p.begin()));
        int offsetlast = int(alast.i - reinterpret_cast<Node *>(p.begin()));
        afirst = begin(); 
        alast = afirst;
        afirst += offsetfirst;
        alast += offsetlast;
    }

    for (Node *n = afirst.i; n < alast.i; ++n)
        node_destruct(n);
    int idx = afirst - begin();
    p.remove(idx, alast - afirst);
    return begin() + idx;
}

template <typename T>
inline QList<T> &QList<T>::operator+=(const QList<T> &l)
{
    if (!l.isEmpty()) {
        if (d == &QListData::shared_null) {
            *this = l;
        } else {
            Node *n = (d->ref.isShared())
                      ? detach_helper_grow(2147483647, l.size())
                      : reinterpret_cast<Node *>(p.append(l.p));
            try {
                node_copy(n, reinterpret_cast<Node *>(p.end()),
                          reinterpret_cast<Node *>(l.p.begin()));
            } catch (...) {
                
                d->end -= int(reinterpret_cast<Node *>(p.end()) - n);
                throw;
            }
        }
    }
    return *this;
}

template <typename T>
inline void QList<T>::append(const QList<T> &t)
{
    *this += t;
}

template <typename T>
inline int QList<T>::indexOf(const T &t, int from) const
{
    return QtPrivate::indexOf<T, T>(*this, t, from);
}

namespace QtPrivate
{
template <typename T, typename U>
int indexOf(const QList<T> &list, const U &u, int from)
{
    typedef typename QList<T>::Node Node;

    if (from < 0)
        from = qMax(from + list.p.size(), 0);
    if (from < list.p.size()) {
        Node *n = reinterpret_cast<Node *>(list.p.at(from -1));
        Node *e = reinterpret_cast<Node *>(list.p.end());
        while (++n != e)
            if (n->t() == u)
                return int(n - reinterpret_cast<Node *>(list.p.begin()));
    }
    return -1;
}
}

template <typename T>
inline int QList<T>::lastIndexOf(const T &t, int from) const
{
    return QtPrivate::lastIndexOf<T, T>(*this, t, from);
}

namespace QtPrivate
{
template <typename T, typename U>
int lastIndexOf(const QList<T> &list, const U &u, int from)
{
    typedef typename QList<T>::Node Node;

    if (from < 0)
        from += list.p.size();
    else if (from >= list.p.size())
        from = list.p.size()-1;
    if (from >= 0) {
        Node *b = reinterpret_cast<Node *>(list.p.begin());
        Node *n = reinterpret_cast<Node *>(list.p.at(from + 1));
        while (n-- != b) {
            if (n->t() == u)
                return int(n - b);
        }
    }
    return -1;
}
}

template <typename T>
inline bool QList<T>::contains(const T &t) const
{
    return contains_impl(t, MemoryLayout());
}

template <typename T>
inline bool QList<T>::contains_impl(const T &t, QListData::NotArrayCompatibleLayout) const
{
    Node *e = reinterpret_cast<Node *>(p.end());
    Node *i = reinterpret_cast<Node *>(p.begin());
    for (; i != e; ++i)
        if (i->t() == t)
            return true;
    return false;
}

template <typename T>
inline bool QList<T>::contains_impl(const T &t, QListData::ArrayCompatibleLayout) const
{
    const T *b = reinterpret_cast<const T*>(p.begin());
    const T *e = reinterpret_cast<const T*>(p.end());
    return std::find(b, e, t) != e;
}

template <typename T>
inline int QList<T>::count(const T &t) const
{
    return this->count_impl(t, MemoryLayout());
}

template <typename T>
inline int QList<T>::count_impl(const T &t, QListData::NotArrayCompatibleLayout) const
{
    int c = 0;
    Node *e = reinterpret_cast<Node *>(p.end());
    Node *i = reinterpret_cast<Node *>(p.begin());
    for (; i != e; ++i)
        if (i->t() == t)
            ++c;
    return c;
}

template <typename T>
inline int QList<T>::count_impl(const T &t, QListData::ArrayCompatibleLayout) const
{
    return int(std::count(reinterpret_cast<const T*>(p.begin()),
                          reinterpret_cast<const T*>(p.end()),
                          t));
}

template <typename T>
inline QVector<T> QList<T>::toVector() const
{
    return QVector<T>(begin(), end());
}

template <typename T>
QList<T> QList<T>::fromVector(const QVector<T> &vector)
{
    return vector.toList();
}

template <typename T>
inline QList<T> QVector<T>::toList() const
{
    return QList<T>(begin(), end());
}

template <typename T>
QVector<T> QVector<T>::fromList(const QList<T> &list)
{
    return list.toVector();
}

template <class T> class QListIterator { typedef typename QList<T>::const_iterator const_iterator; QList<T> c; const_iterator i; public: inline QListIterator(const QList<T> &container) : c(container), i(c.constBegin()) {} inline QListIterator &operator=(const QList<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
template <class T> class QMutableListIterator { typedef typename QList<T>::iterator iterator; typedef typename QList<T>::const_iterator const_iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableListIterator(QList<T> &container) : c(&container) { i = c->begin(); n = c->end(); } inline QMutableListIterator &operator=(QList<T> &container) { c = &container; i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 1154)); return *n; } inline const T &value() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h", 1154)); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };

template <typename T>
uint qHash(const QList<T> &key, uint seed = 0)
    noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
{
    return qHashRange(key.cbegin(), key.cend(), seed);
}

template <typename T>
bool operator<(const QList<T> &lhs, const QList<T> &rhs)
    noexcept(noexcept(std::lexicographical_compare(lhs.begin(), lhs.end(),
                                                               rhs.begin(), rhs.end())))
{
    return std::lexicographical_compare(lhs.begin(), lhs.end(),
                                        rhs.begin(), rhs.end());
}

template <typename T>
inline bool operator>(const QList<T> &lhs, const QList<T> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return rhs < lhs;
}

template <typename T>
inline bool operator<=(const QList<T> &lhs, const QList<T> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return !(lhs > rhs);
}

template <typename T>
inline bool operator>=(const QList<T> &lhs, const QList<T> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return !(lhs < rhs);
}



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"









































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"


















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 43 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"









typedef QListIterator<QByteArray> QByteArrayListIterator;
typedef QMutableListIterator<QByteArray> QMutableByteArrayListIterator;
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"


typedef QList<QByteArray> QByteArrayList;

namespace QtPrivate {
    QByteArray __declspec(dllimport) QByteArrayList_join(const QByteArrayList *that, const char *separator, int separatorLength);
    int __declspec(dllimport) QByteArrayList_indexOf(const QByteArrayList *that, const char *needle, int from);
}
#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"




template <> struct QListSpecialMethods<QByteArray>
#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"
{

protected:
    ~QListSpecialMethods() = default;
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"
public:
    inline QByteArray join() const
    { return QtPrivate::QByteArrayList_join(self(), nullptr, 0); }
    inline QByteArray join(const QByteArray &sep) const
    { return QtPrivate::QByteArrayList_join(self(), sep.constData(), sep.size()); }
    inline QByteArray join(char sep) const
    { return QtPrivate::QByteArrayList_join(self(), &sep, 1); }

    inline int indexOf(const char *needle, int from = 0) const
    { return QtPrivate::QByteArrayList_indexOf(self(), needle, from); }

private:
    typedef QList<QByteArray> Self;
    Self *self() { return static_cast<Self *>(this); }
    const Self *self() const { return static_cast<const Self *>(this); }
};



#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"
#pragma external_header(pop)
#line 1196 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"








































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"


















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"





#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"











































#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"
























































































#pragma external_header(pop)
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qregexp.h"



















































struct QRegExpPrivate;
class QStringList;
class QRegExp;

__declspec(dllimport) uint qHash(const QRegExp &key, uint seed = 0) noexcept;

class __declspec(dllimport) QRegExp
{
public:
    enum PatternSyntax {
        RegExp,
        Wildcard,
        FixedString,
        RegExp2,
        WildcardUnix,
        W3CXmlSchema11 };
    enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };

    QRegExp();
    explicit QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive,
                     PatternSyntax syntax = RegExp);
    QRegExp(const QRegExp &rx);
    ~QRegExp();
    QRegExp &operator=(const QRegExp &rx);
    QRegExp &operator=(QRegExp &&other) noexcept { swap(other); return *this; }
    void swap(QRegExp &other) noexcept { qSwap(priv, other.priv); }

    bool operator==(const QRegExp &rx) const;
    inline bool operator!=(const QRegExp &rx) const { return !operator==(rx); }

    bool isEmpty() const;
    bool isValid() const;
    QString pattern() const;
    void setPattern(const QString &pattern);
    Qt::CaseSensitivity caseSensitivity() const;
    void setCaseSensitivity(Qt::CaseSensitivity cs);
    PatternSyntax patternSyntax() const;
    void setPatternSyntax(PatternSyntax syntax);

    bool isMinimal() const;
    void setMinimal(bool minimal);

    bool exactMatch(const QString &str) const;

    int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const;
    int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const;
    int matchedLength() const;

    int captureCount() const;
    QStringList capturedTexts() const;
    QStringList capturedTexts();
    QString cap(int nth = 0) const;
    QString cap(int nth = 0);
    int pos(int nth = 0) const;
    int pos(int nth = 0);
    QString errorString() const;
    QString errorString();
#line 110 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qregexp.h"

    static QString escape(const QString &str);

    friend __declspec(dllimport) uint qHash(const QRegExp &key, uint seed) noexcept;

private:
    QRegExpPrivate *priv;
};

template<> class QTypeInfo<QRegExp > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QRegExp>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QRegExp>(), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QRegExp >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QRegExp) }; static inline const char *name() { return "QRegExp"; } };


__declspec(dllimport) QDataStream &operator<<(QDataStream &out, const QRegExp &regExp);
__declspec(dllimport) QDataStream &operator>>(QDataStream &in, QRegExp &regExp);
#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qregexp.h"


__declspec(dllimport) QDebug operator<<(QDebug, const QRegExp &);
#line 129 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qregexp.h"



#line 133 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qregexp.h"

#line 135 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qregexp.h"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringmatcher.h"

















































class QStringMatcherPrivate;

class __declspec(dllimport) QStringMatcher
{
public:
    QStringMatcher();
    explicit QStringMatcher(const QString &pattern,
                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QStringMatcher(const QChar *uc, int len,
                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QStringMatcher(QStringView pattern,
                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
    QStringMatcher(const QStringMatcher &other);
    ~QStringMatcher();

    QStringMatcher &operator=(const QStringMatcher &other);

    void setPattern(const QString &pattern);
    void setCaseSensitivity(Qt::CaseSensitivity cs);

    int indexIn(const QString &str, int from = 0) const;
    int indexIn(const QChar *str, int length, int from = 0) const;
    qsizetype indexIn(QStringView str, qsizetype from = 0) const;
    QString pattern() const;
    inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; }

private:
    QStringMatcherPrivate *d_ptr;
    QString q_pattern;
    Qt::CaseSensitivity q_cs;
    struct Data {
        uchar q_skiptable[256];
        const QChar *uc;
        int len;
    };
    union {
        uint q_data[256];
        Data p;
    };
};



#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringmatcher.h"
#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"



class QRegExp;
class QRegularExpression;


typedef QListIterator<QString> QStringListIterator;
typedef QMutableListIterator<QString> QMutableStringListIterator;
#line 61 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"

class QStringList;




template <> struct QListSpecialMethods<QString>
#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
{

protected:
    ~QListSpecialMethods() = default;
#line 74 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
public:
    inline void sort(Qt::CaseSensitivity cs = Qt::CaseSensitive);
    inline int removeDuplicates();


    inline QString join(const QString &sep) const;
#line 81 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
    inline QString join(QStringView sep) const;
    inline QString join(QLatin1String sep) const;
    inline QString join(QChar sep) const;

    inline QStringList filter(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline QStringList &replaceInStrings(QStringView before, QStringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

    inline QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    inline QStringList &replaceInStrings(const QString &before, QStringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
    inline QStringList &replaceInStrings(QStringView before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
#line 93 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


    inline QStringList filter(const QRegExp &rx) const;
    inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after);
#line 98 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


    inline QStringList filter(const QRegularExpression &re) const;
    inline QStringList &replaceInStrings(const QRegularExpression &re, const QString &after);
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


private:
    inline QStringList *self();
    inline const QStringList *self() const;
};


class QStringList : public QList<QString>
{
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
public:
    inline QStringList() noexcept { }
    inline explicit QStringList(const QString &i) { append(i); }
    inline QStringList(const QList<QString> &l) : QList<QString>(l) { }
    inline QStringList(QList<QString> &&l) noexcept : QList<QString>(std::move(l)) { }
    inline QStringList(std::initializer_list<QString> args) : QList<QString>(args) { }
    template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
    inline QStringList(InputIterator first, InputIterator last)
        : QList<QString>(first, last) { }

    QStringList &operator=(const QList<QString> &other)
    { QList<QString>::operator=(other); return *this; }
    QStringList &operator=(QList<QString> &&other) noexcept
    { QList<QString>::operator=(std::move(other)); return *this; }


    inline bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
#line 132 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
    inline bool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
    inline bool contains(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

    inline QStringList operator+(const QStringList &other) const
    { QStringList n = *this; n += other; return n; }
    inline QStringList &operator<<(const QString &str)
    { append(str); return *this; }
    inline QStringList &operator<<(const QStringList &l)
    { *this += l; return *this; }
    inline QStringList &operator<<(const QList<QString> &l)
    { *this += l; return *this; }

    inline int indexOf(QStringView str, int from = 0) const;
    inline int indexOf(QLatin1String str, int from = 0) const;

    inline int lastIndexOf(QStringView str, int from = -1) const;
    inline int lastIndexOf(QLatin1String str, int from = -1) const;


    inline int indexOf(const QRegExp &rx, int from = 0) const;
    inline int lastIndexOf(const QRegExp &rx, int from = -1) const;
    inline int indexOf(QRegExp &rx, int from = 0) const;
    inline int lastIndexOf(QRegExp &rx, int from = -1) const;
#line 156 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


    inline int indexOf(const QRegularExpression &re, int from = 0) const;
    inline int lastIndexOf(const QRegularExpression &re, int from = -1) const;
#line 161 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"

    using QList<QString>::indexOf;
    using QList<QString>::lastIndexOf;
};

template<> class QTypeInfo<QStringList > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QStringList>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QStringList>(), isLarge = (sizeof(QStringList)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QStringList >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QStringList) }; static inline const char *name() { return "QStringList"; } };


inline QStringList *QListSpecialMethods<QString>::self()
{ return static_cast<QStringList *>(this); }
inline const QStringList *QListSpecialMethods<QString>::self() const
{ return static_cast<const QStringList *>(this); }

namespace QtPrivate {
    void __declspec(dllimport) QStringList_sort(QStringList *that, Qt::CaseSensitivity cs);
    int __declspec(dllimport) QStringList_removeDuplicates(QStringList *that);
    QString __declspec(dllimport) QStringList_join(const QStringList *that, QStringView sep);
    QString __declspec(dllimport) QStringList_join(const QStringList *that, const QChar *sep, int seplen);
    __declspec(dllimport) QString QStringList_join(const QStringList &list, QLatin1String sep);
    QStringList __declspec(dllimport) QStringList_filter(const QStringList *that, QStringView str,
                                               Qt::CaseSensitivity cs);

    QStringList __declspec(dllimport) QStringList_filter(const QStringList *that, const QString &str,
                                               Qt::CaseSensitivity cs);
#line 186 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


    bool __declspec(dllimport) QStringList_contains(const QStringList *that, const QString &str, Qt::CaseSensitivity cs);
#line 190 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
    bool __declspec(dllimport) QStringList_contains(const QStringList *that, QStringView str, Qt::CaseSensitivity cs);
    bool __declspec(dllimport) QStringList_contains(const QStringList *that, QLatin1String str, Qt::CaseSensitivity cs);
    void __declspec(dllimport) QStringList_replaceInStrings(QStringList *that, QStringView before, QStringView after,
                                      Qt::CaseSensitivity cs);

    void __declspec(dllimport) QStringList_replaceInStrings(QStringList *that, const QString &before, const QString &after,
                                      Qt::CaseSensitivity cs);
#line 198 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


    void __declspec(dllimport) QStringList_replaceInStrings(QStringList *that, const QRegExp &rx, const QString &after);
    QStringList __declspec(dllimport) QStringList_filter(const QStringList *that, const QRegExp &re);
    int __declspec(dllimport) QStringList_indexOf(const QStringList *that, const QRegExp &rx, int from);
    int __declspec(dllimport) QStringList_lastIndexOf(const QStringList *that, const QRegExp &rx, int from);
    int __declspec(dllimport) QStringList_indexOf(const QStringList *that, QRegExp &rx, int from);
    int __declspec(dllimport) QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int from);
#line 207 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


    void __declspec(dllimport) QStringList_replaceInStrings(QStringList *that, const QRegularExpression &rx, const QString &after);
    QStringList __declspec(dllimport) QStringList_filter(const QStringList *that, const QRegularExpression &re);
    int __declspec(dllimport) QStringList_indexOf(const QStringList *that, const QRegularExpression &re, int from);
    int __declspec(dllimport) QStringList_lastIndexOf(const QStringList *that, const QRegularExpression &re, int from);
#line 214 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
}

inline void QListSpecialMethods<QString>::sort(Qt::CaseSensitivity cs)
{
    QtPrivate::QStringList_sort(self(), cs);
}

inline int QListSpecialMethods<QString>::removeDuplicates()
{
    return QtPrivate::QStringList_removeDuplicates(self());
}


inline QString QListSpecialMethods<QString>::join(const QString &sep) const
{
    return QtPrivate::QStringList_join(self(), sep.constData(), sep.length());
}
#line 232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"

inline QString QListSpecialMethods<QString>::join(QStringView sep) const
{
    return QtPrivate::QStringList_join(self(), sep);
}

QString QListSpecialMethods<QString>::join(QLatin1String sep) const
{
    return QtPrivate::QStringList_join(*self(), sep);
}

inline QString QListSpecialMethods<QString>::join(QChar sep) const
{
    return QtPrivate::QStringList_join(self(), &sep, 1);
}

inline QStringList QListSpecialMethods<QString>::filter(QStringView str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_filter(self(), str, cs);
}


inline QStringList QListSpecialMethods<QString>::filter(const QString &str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_filter(self(), str, cs);
}
#line 259 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


inline bool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_contains(this, str, cs);
}
#line 266 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"

inline bool QStringList::contains(QLatin1String str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_contains(this, str, cs);
}

inline bool QStringList::contains(QStringView str, Qt::CaseSensitivity cs) const
{
    return QtPrivate::QStringList_contains(this, str, cs);
}

inline QStringList &QListSpecialMethods<QString>::replaceInStrings(QStringView before, QStringView after, Qt::CaseSensitivity cs)
{
    QtPrivate::QStringList_replaceInStrings(self(), before, after, cs);
    return *self();
}


inline QStringList &QListSpecialMethods<QString>::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs)
{
    QtPrivate::QStringList_replaceInStrings(self(), before, after, cs);
    return *self();
}

inline QStringList &QListSpecialMethods<QString>::replaceInStrings(QStringView before, const QString &after, Qt::CaseSensitivity cs)
{
    QtPrivate::QStringList_replaceInStrings(self(), before, qToStringViewIgnoringNull(after), cs);
    return *self();
}

inline QStringList &QListSpecialMethods<QString>::replaceInStrings(const QString &before, QStringView after, Qt::CaseSensitivity cs)
{
    QtPrivate::QStringList_replaceInStrings(self(), QStringView(before), after, cs);
    return *self();
}
#line 302 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"

inline QStringList operator+(const QList<QString> &one, const QStringList &other)
{
    QStringList n = one;
    n += other;
    return n;
}

inline int QStringList::indexOf(QStringView string, int from) const
{
    return QtPrivate::indexOf<QString, QStringView>(*this, string, from);
}

inline int QStringList::indexOf(QLatin1String string, int from) const
{
    return QtPrivate::indexOf<QString, QLatin1String>(*this, string, from);
}

inline int QStringList::lastIndexOf(QStringView string, int from) const
{
    return QtPrivate::lastIndexOf<QString, QStringView>(*this, string, from);
}

inline int QStringList::lastIndexOf(QLatin1String string, int from) const
{
    return QtPrivate::lastIndexOf<QString, QLatin1String>(*this, string, from);
}


inline QStringList &QListSpecialMethods<QString>::replaceInStrings(const QRegExp &rx, const QString &after)
{
    QtPrivate::QStringList_replaceInStrings(self(), rx, after);
    return *self();
}

inline QStringList QListSpecialMethods<QString>::filter(const QRegExp &rx) const
{
    return QtPrivate::QStringList_filter(self(), rx);
}

inline int QStringList::indexOf(const QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_indexOf(this, rx, from);
}

inline int QStringList::lastIndexOf(const QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
}

inline int QStringList::indexOf(QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_indexOf(this, rx, from);
}

inline int QStringList::lastIndexOf(QRegExp &rx, int from) const
{
    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
}
#line 362 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


inline QStringList &QListSpecialMethods<QString>::replaceInStrings(const QRegularExpression &rx, const QString &after)
{
    QtPrivate::QStringList_replaceInStrings(self(), rx, after);
    return *self();
}

inline QStringList QListSpecialMethods<QString>::filter(const QRegularExpression &rx) const
{
    return QtPrivate::QStringList_filter(self(), rx);
}

inline int QStringList::indexOf(const QRegularExpression &rx, int from) const
{
    return QtPrivate::QStringList_indexOf(this, rx, from);
}

inline int QStringList::lastIndexOf(const QRegularExpression &rx, int from) const
{
    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
}
#line 385 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
#line 386 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"


inline
QList<QStringView> QStringView::split(QStringView sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
    ((int(m_size) == m_size) ? static_cast<void>(0) : qt_assert("int(m_size) == m_size", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h", 391));
    QString s = QString::fromRawData(data(), int(m_size));
    const auto split = s.splitRef(sep.toString(), behavior, cs);
    QList<QStringView> result;
    for (const QStringRef &r : split)
        result.append(QStringView(m_data + r.position(), r.size()));
    return result;
}

inline
QList<QStringView> QStringView::split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const
{
    ((int(m_size) == m_size) ? static_cast<void>(0) : qt_assert("int(m_size) == m_size", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h", 403));
    QString s = QString::fromRawData(data(), int(m_size));
    const auto split = s.splitRef(sep, behavior, cs);
    QList<QStringView> result;
    for (const QStringRef &r : split)
        result.append(QStringView(m_data + r.position(), r.size()));
    return result;
}



#line 415 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"
#pragma external_header(pop)
#line 1197 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"


#pragma warning( pop )
#line 1201 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"

#line 1203 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlist.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"











































#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"
























































































#pragma external_header(pop)
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"





#pragma warning( push )
#pragma warning( disable : 4311 ) 
#pragma warning( disable : 4127 ) 
#line 59 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"



struct __declspec(dllimport) QHashData
{
    struct Node {
        Node *next;
        uint h;
    };

    Node *fakeNext;
    Node **buckets;
    QtPrivate::RefCount ref;
    int size;
    int nodeSize;
    short userNumBits;
    short numBits;
    int numBuckets;
    uint seed;
    uint sharable : 1;
    uint strictAlignment : 1;
    uint reserved : 30;

    void *allocateNode(int nodeAlign);
    void freeNode(void *node);
    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
                             int nodeSize, int nodeAlign);
    bool willGrow();
    void hasShrunk();
    void rehash(int hint);
    void free_helper(void (*node_delete)(Node *));
    Node *firstNode();




    static Node *nextNode(Node *node);
    static Node *previousNode(Node *node);

    static const QHashData shared_null;
};

inline bool QHashData::willGrow()
{
    if (size >= numBuckets) {
        rehash(numBits + 1);
        return true;
    } else {
        return false;
    }
}

inline void QHashData::hasShrunk()
{
    if (size <= (numBuckets >> 3) && numBits > userNumBits) {
        try {
            rehash(qMax(int(numBits) - 2, int(userNumBits)));
        } catch (const std::bad_alloc &) {
            
        }
    }
}

inline QHashData::Node *QHashData::firstNode()
{
    Node *e = reinterpret_cast<Node *>(this);
    Node **bucket = buckets;
    int n = numBuckets;
    while (n--) {
        if (*bucket != e)
            return *bucket;
        ++bucket;
    }
    return e;
}

struct QHashDummyValue
{
};

constexpr bool operator==(const QHashDummyValue &, const QHashDummyValue &) noexcept
{
    return true;
}

template<> class QTypeInfo<QHashDummyValue > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QHashDummyValue>(), isStatic = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QHashDummyValue>(), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QHashDummyValue >::value, isDummy = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QHashDummyValue) }; static inline const char *name() { return "QHashDummyValue"; } };

template <class Key, class T>
struct QHashNode
{
    QHashNode *next;
    const uint h;
    const Key key;
    T value;

    inline QHashNode(const Key &key0, const T &value0, uint hash, QHashNode *n)
        : next(n), h(hash), key(key0), value(value0) {}
    inline bool same_key(uint h0, const Key &key0) const { return h0 == h && key0 == key; }

private:
    QHashNode(const QHashNode &) = delete; QHashNode &operator=(const QHashNode &) = delete;
};


template <class Key>
struct QHashNode<Key, QHashDummyValue>
{
    union {
        QHashNode *next;
        QHashDummyValue value;
    };
    const uint h;
    const Key key;

    inline QHashNode(const Key &key0, const QHashDummyValue &, uint hash, QHashNode *n)
        : next(n), h(hash), key(key0) {}
    inline bool same_key(uint h0, const Key &key0) const { return h0 == h && key0 == key; }

private:
    QHashNode(const QHashNode &) = delete; QHashNode &operator=(const QHashNode &) = delete;
};










































#line 223 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"

template <class Key, class T>
class QHash
{
    typedef QHashNode<Key, T> Node;

    union {
        QHashData *d;
        QHashNode<Key, T> *e;
    };

    static inline Node *concrete(QHashData::Node *node) {
        return reinterpret_cast<Node *>(node);
    }

    static inline int alignOfNode() { return qMax<int>(sizeof(void*), alignof(Node)); }

public:
    inline QHash() noexcept : d(const_cast<QHashData *>(&QHashData::shared_null)) { }
    inline QHash(std::initializer_list<std::pair<Key,T> > list)
        : d(const_cast<QHashData *>(&QHashData::shared_null))
    {
        reserve(int(list.size()));
        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
            insert(it->first, it->second);
    }
    QHash(const QHash &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
    ~QHash() { if (!d->ref.deref()) freeData(d); }

    QHash &operator=(const QHash &other);
    QHash(QHash &&other) noexcept : d(other.d) { other.d = const_cast<QHashData *>(&QHashData::shared_null); }
    QHash &operator=(QHash &&other) noexcept
    { QHash moved(std::move(other)); swap(moved); return *this; }




    template <typename InputIterator, QtPrivate::IfAssociativeIteratorHasKeyAndValue<InputIterator> = true>
    QHash(InputIterator f, InputIterator l)
        : QHash()
    {
        QtPrivate::reserveIfForwardIterator(this, f, l);
        for (; f != l; ++f)
            insert(f.key(), f.value());
    }

    template <typename InputIterator, QtPrivate::IfAssociativeIteratorHasFirstAndSecond<InputIterator> = true>
    QHash(InputIterator f, InputIterator l)
        : QHash()
    {
        QtPrivate::reserveIfForwardIterator(this, f, l);
        for (; f != l; ++f)
            insert(f->first, f->second);
    }
#line 278 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    void swap(QHash &other) noexcept { qSwap(d, other.d); }

    bool operator==(const QHash &other) const;
    bool operator!=(const QHash &other) const { return !(*this == other); }

    inline int size() const { return d->size; }

    inline bool isEmpty() const { return d->size == 0; }

    inline int capacity() const { return d->numBuckets; }
    void reserve(int size);
    inline void squeeze() { reserve(1); }

    inline void detach() { if (d->ref.isShared()) detach_helper(); }
    inline bool isDetached() const { return !d->ref.isShared(); }

    inline void setSharable(bool sharable) { if (!sharable) detach(); if (d != &QHashData::shared_null) d->sharable = sharable; }
#line 296 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    bool isSharedWith(const QHash &other) const { return d == other.d; }

    void clear();

    int remove(const Key &key);
    T take(const Key &key);

    bool contains(const Key &key) const;
    const Key key(const T &value) const;
    const Key key(const T &value, const Key &defaultKey) const;
    const T value(const Key &key) const;
    const T value(const Key &key, const T &defaultValue) const;
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;

    QList<Key> keys() const;
    QList<Key> keys(const T &value) const;
    QList<T> values() const;



#line 318 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    int count(const Key &key) const;

    class const_iterator;

    class iterator
    {
        friend class const_iterator;
        friend class QHash<Key, T>;
        friend class QSet<Key>;
        QHashData::Node *i;

    public:


#line 333 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        typedef std::forward_iterator_tag iterator_category;
#line 335 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline iterator() : i(nullptr) { }
        explicit inline iterator(void *node) : i(reinterpret_cast<QHashData::Node *>(node)) { }

        inline const Key &key() const { return concrete(i)->key; }
        inline T &value() const { return concrete(i)->value; }
        inline T &operator*() const { return concrete(i)->value; }
        inline T *operator->() const { return &concrete(i)->value; }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }

        inline iterator &operator++() {
            i = QHashData::nextNode(i);
            return *this;
        }
        inline iterator operator++(int) {
            iterator r = *this;
            i = QHashData::nextNode(i);
            return r;
        }


















#line 378 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"








    };
    friend class iterator;

    class const_iterator
    {
        friend class iterator;
        friend class QHash<Key, T>;
        friend class QMultiHash<Key, T>;
        friend class QSet<Key>;
        QHashData::Node *i;

    public:


#line 401 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        typedef std::forward_iterator_tag iterator_category;
#line 403 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        constexpr inline const_iterator() : i(nullptr) { }
        explicit inline const_iterator(void *node)
            : i(reinterpret_cast<QHashData::Node *>(node)) { }

        explicit inline const_iterator(const iterator &o)


#line 416 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        { i = o.i; }

        inline const Key &key() const { return concrete(i)->key; }
        inline const T &value() const { return concrete(i)->value; }
        inline const T &operator*() const { return concrete(i)->value; }
        inline const T *operator->() const { return &concrete(i)->value; }
        constexpr inline bool operator==(const const_iterator &o) const { return i == o.i; }
        constexpr inline bool operator!=(const const_iterator &o) const { return i != o.i; }

        inline const_iterator &operator++() {
            i = QHashData::nextNode(i);
            return *this;
        }
        inline const_iterator operator++(int) {
            const_iterator r = *this;
            i = QHashData::nextNode(i);
            return r;
        }





















#line 456 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"

        

    private:
        inline bool operator==(const iterator &o) const { return operator==(const_iterator(o)); }
        inline bool operator!=(const iterator &o) const { return operator!=(const_iterator(o)); }
#line 463 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    };
    friend class const_iterator;

    class key_iterator
    {
        const_iterator i;

    public:
        typedef typename const_iterator::iterator_category iterator_category;
        typedef typename const_iterator::difference_type difference_type;
        typedef Key value_type;
        typedef const Key *pointer;
        typedef const Key &reference;

        key_iterator() = default;
        explicit key_iterator(const_iterator o) : i(o) { }

        const Key &operator*() const { return i.key(); }
        const Key *operator->() const { return &i.key(); }
        bool operator==(key_iterator o) const { return i == o.i; }
        bool operator!=(key_iterator o) const { return i != o.i; }

        inline key_iterator &operator++() { ++i; return *this; }
        inline key_iterator operator++(int) { return key_iterator(i++);}







#line 495 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        const_iterator base() const { return i; }
    };

    typedef QKeyValueIterator<const Key&, const T&, const_iterator> const_key_value_iterator;
    typedef QKeyValueIterator<const Key&, T&, iterator> key_value_iterator;

    
    inline iterator begin() { detach(); return iterator(d->firstNode()); }
    inline const_iterator begin() const { return const_iterator(d->firstNode()); }
    inline const_iterator cbegin() const { return const_iterator(d->firstNode()); }
    inline const_iterator constBegin() const { return const_iterator(d->firstNode()); }
    inline iterator end() { detach(); return iterator(e); }
    inline const_iterator end() const { return const_iterator(e); }
    inline const_iterator cend() const { return const_iterator(e); }
    inline const_iterator constEnd() const { return const_iterator(e); }
    inline key_iterator keyBegin() const { return key_iterator(begin()); }
    inline key_iterator keyEnd() const { return key_iterator(end()); }
    inline key_value_iterator keyValueBegin() { return key_value_iterator(begin()); }
    inline key_value_iterator keyValueEnd() { return key_value_iterator(end()); }
    inline const_key_value_iterator keyValueBegin() const { return const_key_value_iterator(begin()); }
    inline const_key_value_iterator constKeyValueBegin() const { return const_key_value_iterator(begin()); }
    inline const_key_value_iterator keyValueEnd() const { return const_key_value_iterator(end()); }
    inline const_key_value_iterator constKeyValueEnd() const { return const_key_value_iterator(end()); }

    QPair<iterator, iterator> equal_range(const Key &key);
    QPair<const_iterator, const_iterator> equal_range(const Key &key) const noexcept;
    iterator erase(iterator it) { return erase(const_iterator(it.i)); }
    iterator erase(const_iterator it);

    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return d->size; }
    iterator find(const Key &key);
    const_iterator find(const Key &key) const;
    const_iterator constFind(const Key &key) const;
    iterator insert(const Key &key, const T &value);
    void insert(const QHash &hash);



#line 537 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"

    
    typedef T mapped_type;
    typedef Key key_type;
    typedef qptrdiff difference_type;
    typedef int size_type;

    inline bool empty() const { return isEmpty(); }






private:
    void detach_helper();
    void freeData(QHashData *d);
    Node **findNode(const Key &key, uint *hp = nullptr) const;
    Node **findNode(const Key &key, uint h) const;
    Node *createNode(uint h, const Key &key, const T &value, Node **nextNode);
    void deleteNode(Node *node);
    static void deleteNode2(QHashData::Node *node);

    static void duplicateNode(QHashData::Node *originalNode, void *newNode);

    bool isValidIterator(const iterator &it) const noexcept
    { return isValidNode(it.i); }
    bool isValidIterator(const const_iterator &it) const noexcept
    { return isValidNode(it.i); }
    bool isValidNode(QHashData::Node *node) const noexcept
    {

        while (node->next)
            node = node->next;
        return (static_cast<void *>(node) == d);



#line 576 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    }
    friend class QSet<Key>;
    friend class QMultiHash<Key, T>;
};


template <class Key, class T>
inline void QHash<Key, T>::deleteNode(Node *node)
{
    deleteNode2(reinterpret_cast<QHashData::Node*>(node));
    d->freeNode(node);
}

template <class Key, class T>
inline void QHash<Key, T>::deleteNode2(QHashData::Node *node)
{



    concrete(node)->~Node();
#line 597 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
}

template <class Key, class T>
inline void QHash<Key, T>::duplicateNode(QHashData::Node *node, void *newNode)
{
    Node *concreteNode = concrete(node);
    new (newNode) Node(concreteNode->key, concreteNode->value, concreteNode->h, nullptr);
}

template <class Key, class T>
inline typename QHash<Key, T>::Node *
QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode)
{
    Node *node = new (d->allocateNode(alignOfNode())) Node(akey, avalue, ah, *anextNode);
    *anextNode = node;
    ++d->size;
    return node;
}

template <class Key, class T>
inline void QHash<Key, T>::freeData(QHashData *x)
{
    x->free_helper(deleteNode2);
}

template <class Key, class T>
inline void QHash<Key, T>::clear()
{
    *this = QHash();
}

template <class Key, class T>
inline void QHash<Key, T>::detach_helper()
{
    QHashData *x = d->detach_helper(duplicateNode, deleteNode2, sizeof(Node), alignOfNode());
    if (!d->ref.deref())
        freeData(d);
    d = x;
}

template <class Key, class T>
inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash &other)
{
    if (d != other.d) {
        QHashData *o = other.d;
        o->ref.ref();
        if (!d->ref.deref())
            freeData(d);
        d = o;
        if (!d->sharable)
            detach_helper();
    }
    return *this;
}

template <class Key, class T>
inline const T QHash<Key, T>::value(const Key &akey) const
{
    Node *node;
    if (d->size == 0 || (node = *findNode(akey)) == e) {
        return T();
    } else {
        return node->value;
    }
}

template <class Key, class T>
inline const T QHash<Key, T>::value(const Key &akey, const T &adefaultValue) const
{
    Node *node;
    if (d->size == 0 || (node = *findNode(akey)) == e) {
        return adefaultValue;
    } else {
        return node->value;
    }
}

template <class Key, class T>
inline QList<Key> QHash<Key, T>::keys() const
{
    QList<Key> res;
    res.reserve(size());
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
inline QList<Key> QHash<Key, T>::keys(const T &avalue) const
{
    QList<Key> res;
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
inline const Key QHash<Key, T>::key(const T &avalue) const
{
    return key(avalue, Key());
}

template <class Key, class T>
inline const Key QHash<Key, T>::key(const T &avalue, const Key &defaultValue) const
{
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            return i.key();
        ++i;
    }

    return defaultValue;
}

template <class Key, class T>
inline QList<T> QHash<Key, T>::values() const
{
    QList<T> res;
    res.reserve(size());
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.value());
        ++i;
    }
    return res;
}

template <class Key, class T>
inline int QHash<Key, T>::count(const Key &akey) const
{
    int cnt = 0;
    Node *node = *findNode(akey);
    if (node != e) {
        do {
            ++cnt;
        } while ((node = node->next) != e && node->key == akey);
    }
    return cnt;
}

template <class Key, class T>
inline const T QHash<Key, T>::operator[](const Key &akey) const
{
    return value(akey);
}

template <class Key, class T>
inline T &QHash<Key, T>::operator[](const Key &akey)
{
    detach();

    uint h;
    Node **node = findNode(akey, &h);
    if (*node == e) {
        if (d->willGrow())
            node = findNode(akey, h);
        return createNode(h, akey, T(), node)->value;
    }
    return (*node)->value;
}

template <class Key, class T>
inline typename QHash<Key, T>::iterator QHash<Key, T>::insert(const Key &akey,
                                                                         const T &avalue)
{
    detach();

    uint h;
    Node **node = findNode(akey, &h);
    if (*node == e) {
        if (d->willGrow())
            node = findNode(akey, h);
        return iterator(createNode(h, akey, avalue, node));
    }

    if (!std::is_same<T, QHashDummyValue>::value)
        (*node)->value = avalue;
    return iterator(*node);
}

template <class Key, class T>
inline void QHash<Key, T>::insert(const QHash &hash)
{
    if (d == hash.d)
        return;

    detach();

    QHashData::Node *i = hash.d->firstNode();
    QHashData::Node *end = reinterpret_cast<QHashData::Node *>(hash.e);
    while (i != end) {
        Node *n = concrete(i);
        Node **node = findNode(n->key, n->h);
        if (*node == e) {
            if (d->willGrow())
                node = findNode(n->key, n->h);
            createNode(n->h, n->key, n->value, node);
        } else {
            if (!std::is_same<T, QHashDummyValue>::value)
                (*node)->value = n->value;
        }
        i = QHashData::nextNode(i);
    }
}

template <class Key, class T>
inline int QHash<Key, T>::remove(const Key &akey)
{
    if (isEmpty()) 
        return 0;
    detach();

    int oldSize = d->size;
    Node **node = findNode(akey);
    if (*node != e) {
        bool deleteNext = true;
        do {
            Node *next = (*node)->next;
            deleteNext = (next != e && next->key == (*node)->key);
            deleteNode(*node);
            *node = next;
            --d->size;
        } while (deleteNext);
        d->hasShrunk();
    }
    return oldSize - d->size;
}

template <class Key, class T>
inline T QHash<Key, T>::take(const Key &akey)
{
    if (isEmpty()) 
        return T();
    detach();

    Node **node = findNode(akey);
    if (*node != e) {
        T t = std::move((*node)->value);
        Node *next = (*node)->next;
        deleteNode(*node);
        *node = next;
        --d->size;
        d->hasShrunk();
        return t;
    }
    return T();
}

template <class Key, class T>
inline typename QHash<Key, T>::iterator QHash<Key, T>::erase(const_iterator it)
{
    ((isValidIterator(it)) ? static_cast<void>(0) : qt_assert_x("QHash::erase", "The specified iterator argument 'it' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 856));

    if (it == const_iterator(e))
        return iterator(it.i);

    if (d->ref.isShared()) {
        
        int bucketNum = (it.i->h % d->numBuckets);
        const_iterator bucketIterator(*(d->buckets + bucketNum));
        int stepsFromBucketStartToIte = 0;
        while (bucketIterator != it) {
            ++stepsFromBucketStartToIte;
            ++bucketIterator;
        }
        detach();
        it = const_iterator(*(d->buckets + bucketNum));
        while (stepsFromBucketStartToIte > 0) {
            --stepsFromBucketStartToIte;
            ++it;
        }
    }

    iterator ret(it.i);
    ++ret;

    Node *node = concrete(it.i);
    Node **node_ptr = reinterpret_cast<Node **>(&d->buckets[node->h % d->numBuckets]);
    while (*node_ptr != node)
        node_ptr = &(*node_ptr)->next;
    *node_ptr = node->next;
    deleteNode(node);
    --d->size;
    return ret;
}

template <class Key, class T>
inline void QHash<Key, T>::reserve(int asize)
{
    detach();
    d->rehash(-qMax(asize, 1));
}

template <class Key, class T>
inline typename QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &akey) const
{
    return const_iterator(*findNode(akey));
}

template <class Key, class T>
inline typename QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &akey) const
{
    return const_iterator(*findNode(akey));
}

template <class Key, class T>
inline typename QHash<Key, T>::iterator QHash<Key, T>::find(const Key &akey)
{
    detach();
    return iterator(*findNode(akey));
}

template <class Key, class T>
inline bool QHash<Key, T>::contains(const Key &akey) const
{
    return *findNode(akey) != e;
}

template <class Key, class T>
inline typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey, uint h) const
{
    Node **node;

    if (d->numBuckets) {
        node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]);
        ((*node == e || (*node)->next) ? static_cast<void>(0) : qt_assert("*node == e || (*node)->next", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 930));
        while (*node != e && !(*node)->same_key(h, akey))
            node = &(*node)->next;
    } else {
        node = const_cast<Node **>(reinterpret_cast<const Node * const *>(&e));
    }
    return node;
}

template <class Key, class T>
inline typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey,
                                                                            uint *ahp) const
{
    uint h = 0;

    if (d->numBuckets || ahp) {
        h = qHash(akey, d->seed);
        if (ahp)
            *ahp = h;
    }
    return findNode(akey, h);
}

template <class Key, class T>
inline bool QHash<Key, T>::operator==(const QHash &other) const
{
    if (d == other.d)
        return true;
    if (size() != other.size())
        return false;

    const_iterator it = begin();

    while (it != end()) {
        
        
        auto thisEqualRangeStart = it;
        const Key &thisEqualRangeKey = it.key();
        size_type n = 0;
        do {
            ++it;
            ++n;
        } while (it != end() && it.key() == thisEqualRangeKey);

        const auto otherEqualRange = other.equal_range(thisEqualRangeKey);

        if (n != std::distance(otherEqualRange.first, otherEqualRange.second))
            return false;

        
        if (!qt_is_permutation(thisEqualRangeStart, it, otherEqualRange.first, otherEqualRange.second))
            return false;
    }

    return true;
}

template <class Key, class T>
QPair<typename QHash<Key, T>::iterator, typename QHash<Key, T>::iterator> QHash<Key, T>::equal_range(const Key &akey)
{
    detach();
    auto pair = qAsConst(*this).equal_range(akey);
    return qMakePair(iterator(pair.first.i), iterator(pair.second.i));
}

template <class Key, class T>
QPair<typename QHash<Key, T>::const_iterator, typename QHash<Key, T>::const_iterator> QHash<Key, T>::equal_range(const Key &akey) const noexcept
{
    Node *node = *findNode(akey);
    const_iterator firstIt = const_iterator(node);

    if (node != e) {
        
        
        
        
        while (node->next != e && node->next->key == akey)
            node = node->next;

        
        
        
        
        node = concrete(QHashData::nextNode(reinterpret_cast<QHashData::Node *>(node)));
    }

    return qMakePair(firstIt, const_iterator(node));
}

template <class Key, class T>
class QMultiHash : public QHash<Key, T>
{
public:
    QMultiHash() noexcept {}
    inline QMultiHash(std::initializer_list<std::pair<Key,T> > list)
    {
        this->reserve(int(list.size()));
        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
            insert(it->first, it->second);
    }




    template <typename InputIterator, QtPrivate::IfAssociativeIteratorHasKeyAndValue<InputIterator> = true>
    QMultiHash(InputIterator f, InputIterator l)
    {
        QtPrivate::reserveIfForwardIterator(this, f, l);
        for (; f != l; ++f)
            insert(f.key(), f.value());
    }

    template <typename InputIterator, QtPrivate::IfAssociativeIteratorHasFirstAndSecond<InputIterator> = true>
    QMultiHash(InputIterator f, InputIterator l)
    {
        QtPrivate::reserveIfForwardIterator(this, f, l);
        for (; f != l; ++f)
            insert(f->first, f->second);
    }
#line 1050 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    
    

    QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}
    QMultiHash(QHash<Key, T> &&other) noexcept : QHash<Key, T>(std::move(other)) {}
    void swap(QMultiHash &other) noexcept { QHash<Key, T>::swap(other); } 

    inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value)
    { return QHash<Key, T>::insert(key, value); }

    typename QHash<Key, T>::iterator insert(const Key &key, const T &value);

    inline QMultiHash &unite(const QMultiHash &other);

    inline QMultiHash &operator+=(const QMultiHash &other)
    { return unite(other); }
    inline QMultiHash operator+(const QMultiHash &other) const
    { QMultiHash result = *this; result += other; return result; }

    using QHash<Key, T>::contains;
    using QHash<Key, T>::remove;
    using QHash<Key, T>::count;
    using QHash<Key, T>::find;
    using QHash<Key, T>::constFind;
    using QHash<Key, T>::values;
    using QHash<Key, T>::findNode;
    using QHash<Key, T>::createNode;
    using QHash<Key, T>::concrete;
    using QHash<Key, T>::detach;

    using typename QHash<Key, T>::Node;
    using typename QHash<Key, T>::iterator;
    using typename QHash<Key, T>::const_iterator;

    bool contains(const Key &key, const T &value) const;

    int remove(const Key &key, const T &value);

    int count(const Key &key, const T &value) const;

    QList<Key> uniqueKeys() const;

    QList<T> values(const Key &akey) const;

    typename QHash<Key, T>::iterator find(const Key &key, const T &value) {
        typename QHash<Key, T>::iterator i(find(key));
        typename QHash<Key, T>::iterator end(this->end());
        while (i != end && i.key() == key) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QHash<Key, T>::const_iterator find(const Key &key, const T &value) const {
        typename QHash<Key, T>::const_iterator i(constFind(key));
        typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
        while (i != end && i.key() == key) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QHash<Key, T>::const_iterator constFind(const Key &key, const T &value) const
        { return find(key, value); }
private:
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;
};

template <class Key, class T>
inline typename QHash<Key, T>::iterator QMultiHash<Key, T>::insert(const Key &akey, const T &avalue)
{
    detach();
    this->d->willGrow();

    uint h;
    Node **nextNode = findNode(akey, &h);
    return iterator(createNode(h, akey, avalue, nextNode));
}

template <class Key, class T>
inline QMultiHash<Key, T> &QMultiHash<Key, T>::unite(const QMultiHash &other)
{
    if (this->d == &QHashData::shared_null) {
        *this = other;
    } else {







#line 1146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
        const QMultiHash copy(other);
        const_iterator it = copy.cbegin();
        const const_iterator end = copy.cend();
        while (it != end) {
            const auto rangeStart = it++;
            while (it != end && rangeStart.key() == it.key())
                ++it;
            const qint64 last = std::distance(rangeStart, it) - 1;
            for (qint64 i = last; i >= 0; --i) {
                auto next = std::next(rangeStart, i);
                insert(next.key(), next.value());
            }
        }
#line 1160 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
    }
    return *this;
}


template <class Key, class T>
inline bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const
{
    return constFind(key, value) != QHash<Key, T>::constEnd();
}

template <class Key, class T>
inline int QMultiHash<Key, T>::remove(const Key &key, const T &value)
{
    int n = 0;
    typename QHash<Key, T>::iterator i(find(key));
    typename QHash<Key, T>::iterator end(QHash<Key, T>::end());
    while (i != end && i.key() == key) {
        if (i.value() == value) {
            i = this->erase(i);
            ++n;
        } else {
            ++i;
        }
    }
    return n;
}

template <class Key, class T>
inline int QMultiHash<Key, T>::count(const Key &key, const T &value) const
{
    int n = 0;
    typename QHash<Key, T>::const_iterator i(constFind(key));
    typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
    while (i != end && i.key() == key) {
        if (i.value() == value)
            ++n;
        ++i;
    }
    return n;
}

template <class Key, class T>
inline QList<Key> QMultiHash<Key, T>::uniqueKeys() const
{
    QList<Key> res;
    res.reserve(QHash<Key, T>::size()); 
    typename QHash<Key, T>::const_iterator i = QHash<Key, T>::begin();
    if (i != QHash<Key, T>::end()) {
        for (;;) {
            const Key &aKey = i.key();
            res.append(aKey);
            do {
                if (++i == QHash<Key, T>::end())
                    goto break_out_of_outer_loop;
            } while (aKey == i.key());
        }
    }
break_out_of_outer_loop:
    return res;
}
























#line 1246 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"

template <class Key, class T>
inline QList<T> QMultiHash<Key, T>::values(const Key &akey) const
{
    QList<T> res;
    Node *node = *findNode(akey);
    if (node != this->e) {
        do {
            res.append(node->value);
        } while ((node = node->next) != this->e && node->key == akey);
    }
    return res;
}


template <class Key, class T>
class QHashIterator
{
    typedef typename QHash<Key, T>::const_iterator const_iterator;
    typedef const_iterator Item;
    QHash<Key, T> c;
    const_iterator i, n;
    inline bool item_exists() const { return n != c.constEnd(); }

public:
    inline QHashIterator(const QHash<Key, T> &container)
        : c(container), i(c.constBegin()), n(c.constEnd())
    {
    }
    inline QHashIterator &operator=(const QHash<Key, T> &container)
    {
        c = container;
        i = c.constBegin();
        n = c.constEnd();
        return *this;
    }
    inline void toFront()
    {
        i = c.constBegin();
        n = c.constEnd();
    }
    inline void toBack()
    {
        i = c.constEnd();
        n = c.constEnd();
    }
    inline bool hasNext() const { return i != c.constEnd(); }
    inline Item next()
    {
        n = i++;
        return n;
    }
    inline Item peekNext() const { return i; }
    inline const T &value() const
    {
        ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 1301));
        return *n;
    }
    inline const Key &key() const
    {
        ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 1306));
        return n.key();
    }
    inline bool findNext(const T &t)
    {
        while ((n = i) != c.constEnd())
            if (*i++ == t)
                return true;
        return false;
    }




















#line 1337 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
};

template<class Key, class T>
class QMutableHashIterator
{
    typedef typename QHash<Key, T>::iterator iterator;
    typedef typename QHash<Key, T>::const_iterator const_iterator;
    typedef iterator Item;
    QHash<Key, T> *c;
    iterator i, n;
    inline bool item_exists() const { return const_iterator(n) != c->constEnd(); }

public:
    inline QMutableHashIterator(QHash<Key, T> &container) : c(&container)
    {
        i = c->begin();
        n = c->end();
    }
    inline QMutableHashIterator &operator=(QHash<Key, T> &container)
    {
        c = &container;
        i = c->begin();
        n = c->end();
        return *this;
    }
    inline void toFront()
    {
        i = c->begin();
        n = c->end();
    }
    inline void toBack()
    {
        i = c->end();
        n = c->end();
    }
    inline bool hasNext() const { return const_iterator(i) != c->constEnd(); }
    inline Item next()
    {
        n = i++;
        return n;
    }
    inline Item peekNext() const { return i; }
    inline void remove()
    {
        if (const_iterator(n) != c->constEnd()) {
            i = c->erase(n);
            n = c->end();
        }
    }
    inline void setValue(const T &t)
    {
        if (const_iterator(n) != c->constEnd())
            *n = t;
    }
    inline T &value()
    {
        ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 1393));
        return *n;
    }
    inline const T &value() const
    {
        ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 1398));
        return *n;
    }
    inline const Key &key() const
    {
        ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h", 1403));
        return n.key();
    }
    inline bool findNext(const T &t)
    {
        while (const_iterator(n = i) != c->constEnd())
            if (*i++ == t)
                return true;
        return false;
    }




















#line 1434 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
};
#line 1436 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"

template <class Key, class T>
uint qHash(const QHash<Key, T> &key, uint seed = 0)
    noexcept(noexcept(qHash(std::declval<Key&>())) && noexcept(qHash(std::declval<T&>())))
{
    QtPrivate::QHashCombineCommutative hash;
    for (auto it = key.begin(), end = key.end(); it != end; ++it) {
        const Key &k = it.key();
        const T   &v = it.value();
        seed = hash(seed, std::pair<const Key&, const T&>(k, v));
    }
    return seed;
}

template <class Key, class T>
inline uint qHash(const QMultiHash<Key, T> &key, uint seed = 0)
    noexcept(noexcept(qHash(std::declval<Key&>())) && noexcept(qHash(std::declval<T&>())))
{
    const QHash<Key, T> &key2 = key;
    return qHash(key2, seed);
}




#pragma warning( pop )
#line 1463 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"

#line 1465 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qhash.h"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"





















































#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"





#pragma once






#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"

    [[nodiscard]] bool operator==(_Default_sentinel) const noexcept {
        return !!_Ptr->_Isnil; 
                               
    }





#line 116 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Mytree*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 182, 0, "%s", "cannot dereference value-initialized map/set iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized map/set iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 182, 0); } while (false); } ; } while (false);
        do { if (this->_Ptr != _Mycont->_Myhead) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 183, 0, "%s", "cannot dereference end map/set iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end map/set iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 183, 0); } while (false); } ; } while (false);
#line 185 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"

        return this->_Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Tree_const_iterator& operator++() noexcept {

        do { if (this->_Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 195, 0, "%s", "cannot increment value-initialized map/set iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized map/set iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 195, 0); } while (false); } ; } while (false);
        do { if (!this->_Ptr->_Isnil) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 196, 0, "%s", "cannot increment end map/set iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment end map/set iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 196, 0); } while (false); } ; } while (false);
#line 198 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"

        _Mybase::operator++();
        return *this;
    }

    _Tree_const_iterator operator++(int) noexcept {
        _Tree_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    _Tree_const_iterator& operator--() noexcept {

        do { if (this->_Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 211, 0, "%s", "cannot decrement value-initialized map/set iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized map/set iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 211, 0); } while (false); } ; } while (false);
        _Nodeptr _Ptrsav = this->_Ptr;
        _Mybase::operator--();
        do { if (_Ptrsav != this->_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 214, 0, "%s", "cannot decrement begin map/set iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement begin map/set iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 214, 0); } while (false); } ; } while (false);


#line 218 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 230, 0, "%s", "map/set iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 230, 0); } while (false); } ; } while (false);
#line 232 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"

        return this->_Ptr == _Right._Ptr;
    }





#line 241 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"


    friend void _Verify_range(const _Tree_const_iterator& _First, const _Tree_const_iterator& _Last) noexcept {
        do { if (_First._Getcont() == _Last._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 244, 0, "%s", "map/set iterators in range are from different containers")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set iterators in range are from different containers\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 244, 0); } while (false); } ; } while (false);
    }
#line 247 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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 = 
        _Returns_exactly<value_type>(); 

    enum _Redbl { 
        _Red,
        _Black
    };

    _Tree_node()                             = default;
    _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 {

        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
        while (*_Pnext) {
            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
            if (_Pnextptr == _Myhead || (_Ptr != nullptr && _Pnextptr != _Ptr)) {
                _Pnext = &(*_Pnext)->_Mynextiter;
            } else { 
                (*_Pnext)->_Myproxy = nullptr;
                *_Pnext             = (*_Pnext)->_Mynextiter;
            }
        }


#line 731 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 key_type       = typename _Traits::key_type;
    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, _Nodeptr>>>;

    static constexpr bool _Multi  = _Traits::_Multi;
    static constexpr bool _Is_set = is_same_v<key_type, value_type>;

    enum _Redbl { 
        _Red,
        _Black
    };

public:
    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_set, _Tree_const_iterator<_Scary_val>, _Tree_iterator<_Scary_val>>;
    using const_iterator = _Tree_const_iterator<_Scary_val>;
    using _Unchecked_iterator =
        conditional_t<_Is_set, _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>;

    enum class _Strategy : bool {
        _Copy,
        _Move,
    };

    _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   = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        const auto _Scary = _Get_scary();
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
        _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
        _Copy<_Strategy::_Copy>(_Right);
        _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);
    }

    _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()) {
                auto&& _Alproxy   = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
                const auto _Scary = _Get_scary();
                _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
                _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
                _Copy<_Strategy::_Move>(_Right);
                _Sentinel._Release();
                _Proxy._Release();
                return;
            }
        }

        _Alloc_sentinel_and_proxy();
        _Swap_val_excluding_comp(_Right);
    }

    _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       = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al);
                auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al);
                _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<_Strategy::_Move>(_Right);
                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) { 
        using ::std:: swap;
        const auto _Scary       = _Get_scary();
        const auto _Right_scary = _Right._Get_scary();
        _Scary->_Swap_proxy_and_iterators(*_Right_scary);
        swap(_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();

        do { if (_Where._Getcont() == _Scary) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1067, 0, "%s", "map/set insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1067, 0); } while (false); } ; } while (false);
#line 1069 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
        return iterator(_Emplace_hint(_Where._Ptr, ::std:: forward<_Valtys>(_Vals)...), _Scary);
    }

    ~_Tree() noexcept {
        const auto _Scary = _Get_scary();
        _Scary->_Erase_head(_Getal());

        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _Delete_plain_internal(_Alproxy, _Scary->_Myproxy);
#line 1079 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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       = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al);
                auto&& _Right_alproxy = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al);
                _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<_Strategy::_Copy>(_Right);
                return *this;
            }
        }

        clear();
        _Getcomp() = _Right._Getcomp();
        _Pocca(_Al, _Right_al);
        _Copy<_Strategy::_Copy>(_Right);

        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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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();

        do { if (_Where._Getcont() == _Scary) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1235, 0, "%s", "map/set insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1235, 0); } while (false); } ; } while (false);
#line 1237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
        return iterator(_Emplace_hint(_Where._Ptr, _Val), _Scary);
    }

    iterator insert(const_iterator _Where, value_type&& _Val) {
        const auto _Scary = _Get_scary();

        do { if (_Where._Getcont() == _Scary) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1243, 0, "%s", "map/set insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1243, 0); } while (false); } ; } while (false);
#line 1245 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
        return iterator(_Emplace_hint(_Where._Ptr, ::std:: move(_Val)), _Scary);
    }

protected:
    template <class _Iter, class _Sent>
    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
        const auto _Myhead = _Get_scary()->_Myhead;
        for (; _First != _Last; ++_First) {
            _Emplace_hint(_Myhead, *_First);
        }
    }

public:
    template <class _Iter>
    void insert(_Iter _First, _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        _Insert_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }






#line 1270 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"

    void insert(initializer_list<value_type> _Ilist) {
        _Insert_range_unchecked(_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();

        do { if (_Where._Getcont() == _Scary) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1315, 0, "%s", "map/set erase iterator from incorrect container")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set erase iterator from incorrect container\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1315, 0); } while (false); } ; } while (false);
        do { if (!_Where._Ptr->_Isnil) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1316, 0, "%s", "cannot erase map/set end() iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot erase map/set end() iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1316, 0); } while (false); } ; } while (false);
#line 1318 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
    }

    iterator erase(const_iterator _Where) noexcept  {
        const auto _Scary = _Get_scary();

        do { if (_Where._Getcont() == _Scary) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1324, 0, "%s", "map/set erase iterator from incorrect container")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set erase iterator from incorrect container\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1324, 0); } while (false); } ; } while (false);
        do { if (!_Where._Ptr->_Isnil) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1325, 0, "%s", "cannot erase map/set end() iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot erase map/set end() iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1325, 0); } while (false); } ; } while (false);
#line 1327 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }









#line 1347 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[nodiscard]] iterator find(const _Other& _Keyval) {
        return iterator(_Find(_Keyval), _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[nodiscard]] bool contains(const _Other& _Keyval) const {
        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
    }
#line 1399 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[nodiscard]] iterator lower_bound(const _Other& _Keyval) {
        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[nodiscard]] iterator upper_bound(const _Other& _Keyval) {
        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[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, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
    [[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)  {
        using ::std:: swap;
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Swap_val_excluding_comp(_Right);
            swap(_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 || !_Debug_lt_pred(_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 (!_Debug_lt_pred(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
                    return {{_Hint, _Tree_child::_Left}, false};
                }

                
                return {_Find_lower_bound(_Keyval)._Location, false};
            }

            if (!_Debug_lt_pred(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
                
                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
                if (!_Debug_lt_pred(_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 || _Debug_lt_pred(_Comp, _Traits::_Kfn(_Head->_Right->_Myval), _Keyval)) {
                    return {{_Head->_Right, _Tree_child::_Right}, false};
                }
            } else if (_Hint == _Head->_Left) {
                
                if (_Debug_lt_pred(_Comp, _Keyval, _Traits::_Kfn(_Hint->_Myval))) {
                    return {{_Hint, _Tree_child::_Left}, false};
                }
            } else if (_Debug_lt_pred(_Comp, _Keyval, _Traits::_Kfn(_Hint->_Myval))) {
                
                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
                if (_Debug_lt_pred(_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 (_Debug_lt_pred(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
                
                const auto _Next = (++(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
                if (_Next->_Isnil || _Debug_lt_pred(_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 (_Debug_lt_pred(_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 && !_Debug_lt_pred(_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 (_Debug_lt_pred(_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 <_Strategy _Strat>
    void _Copy(const _Tree& _Right) { 
        const auto _Scary        = _Get_scary();
        const auto _Right_scary  = _Right._Get_scary();
        _Scary->_Myhead->_Parent = _Copy_nodes<_Strat>(_Right_scary->_Myhead->_Parent, _Scary->_Myhead);
        _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 <_Strategy _Strat, class _Ty>
    _Nodeptr _Copy_or_move(_Ty& _Val) {
        if constexpr (_Strat == _Strategy::_Copy) {
            return _Buynode(_Val);
        } else {
            if constexpr (_Is_set) {
                return _Buynode(::std:: move(_Val));
            } else {
                return _Buynode(::std:: move(const_cast<key_type&>(_Val.first)), ::std:: move(_Val.second));
            }
        }
    }

    template <_Strategy _Strat>
    _Nodeptr _Copy_nodes(_Nodeptr _Rootnode, _Nodeptr _Wherenode) {
        
        const auto _Scary = _Get_scary();
        _Nodeptr _Newroot = _Scary->_Myhead; 

        if (!_Rootnode->_Isnil) { 
            _Nodeptr _Pnode = _Copy_or_move<_Strat>(_Rootnode->_Myval);
            _Pnode->_Parent = _Wherenode;
            _Pnode->_Color  = _Rootnode->_Color;
            if (_Newroot->_Isnil) {
                _Newroot = _Pnode; 
            }

            try {
            _Pnode->_Left  = _Copy_nodes<_Strat>(_Rootnode->_Left, _Pnode);
            _Pnode->_Right = _Copy_nodes<_Strat>(_Rootnode->_Right, _Pnode);
            } 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 (_Debug_lt_pred(_Comp, _Nodekey, _Keyval)) {
                _Pnode = _Pnode->_Right; 
            } else { 
                if (_Hinode->_Isnil && _Debug_lt_pred(_Comp, _Keyval, _Nodekey)) {
                    _Hinode = _Pnode; 
                }

                _Lonode = _Pnode;
                _Pnode  = _Pnode->_Left; 
            }
        }

        _Pnode = _Hinode->_Isnil ? _Scary->_Myhead->_Parent : _Hinode->_Left; 
        while (!_Pnode->_Isnil) {
            if (_Debug_lt_pred(_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();

        do { if (_Where._Getcont() == _Scary && !_Where._Ptr->_Isnil) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1729, 0, "%s", "map/set erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1729, 0); } while (false); } ; } while (false);
#line 1731 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }














#line 1760 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();

        do { if (_Hint._Getcont() == _Scary) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1805, 0, "%s", "map/set insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"map/set insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1805, 0); } while (false); } ; } while (false);
#line 1807 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
            }
        }


        if constexpr (!_Alnode_traits::is_always_equal::value) {
            do { if (_Getal() == _That._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1848, 0, "%s", "allocator incompatible for merge")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"allocator incompatible for merge\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1848, 0); } while (false); } ; } while (false);
        }
#line 1851 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

        _Lockit _Lock(3);
        const auto _Old_parent_scary = _Old_parent._Get_scary();
        _Iterator_base12** _Pnext    = &_Old_parent_scary->_Myproxy->_Myfirstiter;
        do { if (_Pnext) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1904, 0, "%s", "source container corrupted")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"source container corrupted\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1904, 0); } while (false); } ; } while (false);
        if (_Ptr == nullptr || _Ptr == _Old_parent_scary->_Myhead) {
            return;
        }

        const auto _My_saved_proxy               = _Get_scary()->_Myproxy;
        _Iterator_base12** const _My_saved_first = &_My_saved_proxy->_Myfirstiter;

        while (*_Pnext) {
            _Iterator_base12** const _Next = &(*_Pnext)->_Mynextiter;
            const auto _Iter               = static_cast<const_iterator*>(*_Pnext);
            if (_Iter->_Ptr == _Ptr) { 
                *_Pnext            = *_Next;
                _Iter->_Myproxy    = _My_saved_proxy;
                _Iter->_Mynextiter = *_My_saved_first;
                *_My_saved_first   = _Iter;
            } else { 
                _Pnext = _Next;
            }
        }
#line 1925 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
    }

    void _Check_node_allocator(node_type& _Handle) const {
        (void) _Handle;

        do { if (get_allocator() == _Handle._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1930, 0, "%s", "node handle allocator incompatible for insert")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"node handle allocator incompatible for insert\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree", 1930, 0); } while (false); } ; } while (false);
#line 1932 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
    }
#line 1934 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"

    void _Alloc_sentinel_and_proxy() {
        const auto _Scary = _Get_scary();
        auto&& _Alproxy   = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _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 1982 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
#line 1983 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xtree"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"



#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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:
        using _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 suppress this warning.")]]  = value_type;
        using _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 suppress this warning.")]] = value_type;
        using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

        [[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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

    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 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }





















#line 160 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"

    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 398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"
#line 399 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 412 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 442 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 455 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

    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);
    }





















#line 540 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"

    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 631 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"
#line 632 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 647 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 681 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 695 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 705 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"
}


#pragma warning(pop)
#pragma pack(pop)
#line 711 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"
#line 712 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\map"
#pragma external_header(pop)
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"











template <class Key> inline bool qMapLessThanKey(const Key &key1, const Key &key2)
{
    return key1 < key2;
}

template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2)
{
    return std::less<const Ptr *>()(key1, key2);
}

struct QMapDataBase;
template <class Key, class T> struct QMapData;

struct __declspec(dllimport) QMapNodeBase
{
    quintptr p;
    QMapNodeBase *left;
    QMapNodeBase *right;

    enum Color { Red = 0, Black = 1 };
    enum { Mask = 3 }; 

    const QMapNodeBase *nextNode() const;
    QMapNodeBase *nextNode() { return const_cast<QMapNodeBase *>(const_cast<const QMapNodeBase *>(this)->nextNode()); }
    const QMapNodeBase *previousNode() const;
    QMapNodeBase *previousNode() { return const_cast<QMapNodeBase *>(const_cast<const QMapNodeBase *>(this)->previousNode()); }

    Color color() const { return Color(p & 1); }
    void setColor(Color c) { if (c == Black) p |= Black; else p &= ~Black; }
    QMapNodeBase *parent() const { return reinterpret_cast<QMapNodeBase *>(p & ~Mask); }
    void setParent(QMapNodeBase *pp) { p = (p & Mask) | quintptr(pp); }

    template <typename T>
    static typename std::enable_if<QTypeInfo<T>::isComplex>::type
    callDestructorIfNecessary(T &t) noexcept { (void)t;; t.~T(); } 
    template <typename T>
    static typename std::enable_if<!QTypeInfo<T>::isComplex>::type
    callDestructorIfNecessary(T &) noexcept {}
};

template <class Key, class T>
struct QMapNode : public QMapNodeBase
{
    Key key;
    T value;

    inline QMapNode *leftNode() const { return static_cast<QMapNode *>(left); }
    inline QMapNode *rightNode() const { return static_cast<QMapNode *>(right); }

    inline const QMapNode *nextNode() const { return reinterpret_cast<const QMapNode *>(QMapNodeBase::nextNode()); }
    inline const QMapNode *previousNode() const { return static_cast<const QMapNode *>(QMapNodeBase::previousNode()); }
    inline QMapNode *nextNode() { return reinterpret_cast<QMapNode *>(QMapNodeBase::nextNode()); }
    inline QMapNode *previousNode() { return static_cast<QMapNode *>(QMapNodeBase::previousNode()); }

    QMapNode<Key, T> *copy(QMapData<Key, T> *d) const;

    void destroySubTree()
    {
        callDestructorIfNecessary(key);
        callDestructorIfNecessary(value);
        doDestroySubTree(std::integral_constant<bool, QTypeInfo<T>::isComplex || QTypeInfo<Key>::isComplex>());
    }

    QMapNode<Key, T> *lowerBound(const Key &key);
    QMapNode<Key, T> *upperBound(const Key &key);

private:
    void doDestroySubTree(std::false_type) {}
    void doDestroySubTree(std::true_type)
    {
        if (left)
            leftNode()->destroySubTree();
        if (right)
            rightNode()->destroySubTree();
    }

    QMapNode() = delete;
    QMapNode(const QMapNode &) = delete; QMapNode &operator=(const QMapNode &) = delete;
    friend struct QMapNodeBase;
};

template <class Key, class T>
inline QMapNode<Key, T> *QMapNode<Key, T>::lowerBound(const Key &akey)
{
    QMapNode<Key, T> *n = this;
    QMapNode<Key, T> *lastNode = nullptr;
    while (n) {
        if (!qMapLessThanKey(n->key, akey)) {
            lastNode = n;
            n = n->leftNode();
        } else {
            n = n->rightNode();
        }
    }
    return lastNode;
}

template <class Key, class T>
inline QMapNode<Key, T> *QMapNode<Key, T>::upperBound(const Key &akey)
{
    QMapNode<Key, T> *n = this;
    QMapNode<Key, T> *lastNode = nullptr;
    while (n) {
        if (qMapLessThanKey(akey, n->key)) {
            lastNode = n;
            n = n->leftNode();
        } else {
            n = n->rightNode();
        }
    }
    return lastNode;
}



struct __declspec(dllimport) QMapDataBase
{
    QtPrivate::RefCount ref;
    int size;
    QMapNodeBase header;
    QMapNodeBase *mostLeftNode;

    void rotateLeft(QMapNodeBase *x);
    void rotateRight(QMapNodeBase *x);
    void rebalance(QMapNodeBase *x);
    void freeNodeAndRebalance(QMapNodeBase *z);
    void recalcMostLeftNode();

    QMapNodeBase *createNode(int size, int alignment, QMapNodeBase *parent, bool left);
    void freeTree(QMapNodeBase *root, int alignment);

    static const QMapDataBase shared_null;

    static QMapDataBase *createData();
    static void freeData(QMapDataBase *d);
};

template <class Key, class T>
struct QMapData : public QMapDataBase
{
    typedef QMapNode<Key, T> Node;

    Node *root() const { return static_cast<Node *>(header.left); }

    
    
__pragma(warning(push))

    const Node *end() const { return reinterpret_cast<const Node *>(&header); }
    Node *end() { return reinterpret_cast<Node *>(&header); }
__pragma(warning(pop))
    const Node *begin() const { if (root()) return static_cast<const Node*>(mostLeftNode); return end(); }
    Node *begin() { if (root()) return static_cast<Node*>(mostLeftNode); return end(); }

    void deleteNode(Node *z);
    Node *findNode(const Key &akey) const;
    void nodeRange(const Key &akey, Node **firstNode, Node **lastNode);

    Node *createNode(const Key &k, const T &v, Node *parent = nullptr, bool left = false)
    {
        Node *n = static_cast<Node *>(QMapDataBase::createNode(sizeof(Node), alignof(Node),
                                      parent, left));
        try {
            new (&n->key) Key(k);
            try {
                new (&n->value) T(v);
            } catch (...) {
                n->key.~Key();
                throw;
            }
        } catch (...) {
            QMapDataBase::freeNodeAndRebalance(n);
            throw;
        }
        return n;
    }

    static QMapData *create() {
        return static_cast<QMapData *>(createData());
    }

    void destroy() {
        if (root()) {
            root()->destroySubTree();
            freeTree(header.left, alignof(Node));
        }
        freeData(this);
    }
};

template <class Key, class T>
QMapNode<Key, T> *QMapNode<Key, T>::copy(QMapData<Key, T> *d) const
{
    QMapNode<Key, T> *n = d->createNode(key, value);
    n->setColor(color());
    if (left) {
        n->left = leftNode()->copy(d);
        n->left->setParent(n);
    } else {
        n->left = nullptr;
    }
    if (right) {
        n->right = rightNode()->copy(d);
        n->right->setParent(n);
    } else {
        n->right = nullptr;
    }
    return n;
}

template <class Key, class T>
void QMapData<Key, T>::deleteNode(QMapNode<Key, T> *z)
{
    QMapNodeBase::callDestructorIfNecessary(z->key);
    QMapNodeBase::callDestructorIfNecessary(z->value);
    freeNodeAndRebalance(z);
}

template <class Key, class T>
QMapNode<Key, T> *QMapData<Key, T>::findNode(const Key &akey) const
{
    if (Node *r = root()) {
        Node *lb = r->lowerBound(akey);
        if (lb && !qMapLessThanKey(akey, lb->key))
            return lb;
    }
    return nullptr;
}


template <class Key, class T>
void QMapData<Key, T>::nodeRange(const Key &akey, QMapNode<Key, T> **firstNode, QMapNode<Key, T> **lastNode)
{
    Node *n = root();
    Node *l = end();
    while (n) {
        if (qMapLessThanKey(akey, n->key)) {
            l = n;
            n = n->leftNode();
        } else if (qMapLessThanKey(n->key, akey)) {
            n = n->rightNode();
        } else {
            *firstNode = n->leftNode() ? n->leftNode()->lowerBound(akey) : nullptr;
            if (!*firstNode)
                *firstNode = n;
            *lastNode = n->rightNode() ? n->rightNode()->upperBound(akey) : nullptr;
            if (!*lastNode)
                *lastNode = l;
            return;
        }
    }
    *firstNode = *lastNode = l;
}


template <class Key, class T>
class QMap
{
    typedef QMapNode<Key, T> Node;

    QMapData<Key, T> *d;

public:
    inline QMap() noexcept : d(static_cast<QMapData<Key, T> *>(const_cast<QMapDataBase *>(&QMapDataBase::shared_null))) { }
    inline QMap(std::initializer_list<std::pair<Key,T> > list)
        : d(static_cast<QMapData<Key, T> *>(const_cast<QMapDataBase *>(&QMapDataBase::shared_null)))
    {
        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
            insert(it->first, it->second);
    }
    QMap(const QMap<Key, T> &other);

    inline ~QMap() { if (!d->ref.deref()) d->destroy(); }

    QMap<Key, T> &operator=(const QMap<Key, T> &other);
    inline QMap(QMap<Key, T> &&other) noexcept
        : d(other.d)
    {
        other.d = static_cast<QMapData<Key, T> *>(
                const_cast<QMapDataBase *>(&QMapDataBase::shared_null));
    }

    inline QMap<Key, T> &operator=(QMap<Key, T> &&other) noexcept
    { QMap moved(std::move(other)); swap(moved); return *this; }
    inline void swap(QMap<Key, T> &other) noexcept { qSwap(d, other.d); }
    explicit QMap(const typename std::map<Key, T> &other);
    std::map<Key, T> toStdMap() const;

    bool operator==(const QMap<Key, T> &other) const;
    inline bool operator!=(const QMap<Key, T> &other) const { return !(*this == other); }

    inline int size() const { return d->size; }

    inline bool isEmpty() const { return d->size == 0; }

    inline void detach() { if (d->ref.isShared()) detach_helper(); }
    inline bool isDetached() const { return !d->ref.isShared(); }

    inline void setSharable(bool sharable)
    {
        if (sharable == d->ref.isSharable())
            return;
        if (!sharable)
            detach();
        
        d->ref.setSharable(sharable);
    }
#line 374 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"
    inline bool isSharedWith(const QMap<Key, T> &other) const { return d == other.d; }

    void clear();

    int remove(const Key &key);
    T take(const Key &key);

    bool contains(const Key &key) const;
    const Key key(const T &value, const Key &defaultKey = Key()) const;
    const T value(const Key &key, const T &defaultValue = T()) const;
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;

    QList<Key> keys() const;
    QList<Key> keys(const T &value) const;
    QList<T> values() const;



#line 394 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"
    int count(const Key &key) const;


    inline const Key &firstKey() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 397)); return constBegin().key(); }
    inline const Key &lastKey() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 398)); return (constEnd() - 1).key(); }

    inline T &first() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 400)); return *begin(); }
    inline const T &first() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 401)); return *constBegin(); }
    inline T &last() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 402)); return *(end() - 1); }
    inline const T &last() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 403)); return *(constEnd() - 1); }

    class const_iterator;

    class iterator
    {
        friend class const_iterator;
        Node *i;

    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline iterator() : i(nullptr) { }
        inline iterator(Node *node) : i(node) { }

        inline const Key &key() const { return i->key; }
        inline T &value() const { return i->value; }
        inline T &operator*() const { return i->value; }
        inline T *operator->() const { return &i->value; }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }

        inline iterator &operator++() {
            i = i->nextNode();
            return *this;
        }
        inline iterator operator++(int) {
            iterator r = *this;
            i = i->nextNode();
            return r;
        }
        inline iterator &operator--() {
            i = i->previousNode();
            return *this;
        }
        inline iterator operator--(int) {
            iterator r = *this;
            i = i->previousNode();
            return r;
        }
        inline iterator operator+(int j) const
        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
        inline iterator operator-(int j) const { return operator+(-j); }
        inline iterator &operator+=(int j) { return *this = *this + j; }
        inline iterator &operator-=(int j) { return *this = *this - j; }
        friend inline iterator operator+(int j, iterator k) { return k + j; }








        friend class QMap<Key, T>;
        friend class QMultiMap<Key, T>;
    };
    friend class iterator;

    class const_iterator
    {
        friend class iterator;
        const Node *i;

    public:
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        constexpr inline const_iterator() : i(nullptr) { }
        inline const_iterator(const Node *node) : i(node) { }

        explicit inline const_iterator(const iterator &o)


#line 485 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"
        { i = o.i; }

        inline const Key &key() const { return i->key; }
        inline const T &value() const { return i->value; }
        inline const T &operator*() const { return i->value; }
        inline const T *operator->() const { return &i->value; }
        constexpr inline bool operator==(const const_iterator &o) const { return i == o.i; }
        constexpr inline bool operator!=(const const_iterator &o) const { return i != o.i; }

        inline const_iterator &operator++() {
            i = i->nextNode();
            return *this;
        }
        inline const_iterator operator++(int) {
            const_iterator r = *this;
            i = i->nextNode();
            return r;
        }
        inline const_iterator &operator--() {
            i = i->previousNode();
            return *this;
        }
        inline const_iterator operator--(int) {
            const_iterator r = *this;
            i = i->previousNode();
            return r;
        }
        inline const_iterator operator+(int j) const
        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
        inline const_iterator operator-(int j) const { return operator+(-j); }
        inline const_iterator &operator+=(int j) { return *this = *this + j; }
        inline const_iterator &operator-=(int j) { return *this = *this - j; }
        friend inline const_iterator operator+(int j, const_iterator k) { return k + j; }


    private:
        inline bool operator==(const iterator &o) const { return operator==(const_iterator(o)); }
        inline bool operator!=(const iterator &o) const { return operator!=(const_iterator(o)); }
#line 524 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"
        friend class QMap<Key, T>;
        friend class QMultiMap<Key, T>;
    };
    friend class const_iterator;

    class key_iterator
    {
        const_iterator i;

    public:
        typedef typename const_iterator::iterator_category iterator_category;
        typedef typename const_iterator::difference_type difference_type;
        typedef Key value_type;
        typedef const Key *pointer;
        typedef const Key &reference;

        key_iterator() = default;
        explicit key_iterator(const_iterator o) : i(o) { }

        const Key &operator*() const { return i.key(); }
        const Key *operator->() const { return &i.key(); }
        bool operator==(key_iterator o) const { return i == o.i; }
        bool operator!=(key_iterator o) const { return i != o.i; }

        inline key_iterator &operator++() { ++i; return *this; }
        inline key_iterator operator++(int) { return key_iterator(i++);}
        inline key_iterator &operator--() { --i; return *this; }
        inline key_iterator operator--(int) { return key_iterator(i--); }
        const_iterator base() const { return i; }
    };

    typedef QKeyValueIterator<const Key&, const T&, const_iterator> const_key_value_iterator;
    typedef QKeyValueIterator<const Key&, T&, iterator> key_value_iterator;

    
    inline iterator begin() { detach(); return iterator(d->begin()); }
    inline const_iterator begin() const { return const_iterator(d->begin()); }
    inline const_iterator constBegin() const { return const_iterator(d->begin()); }
    inline const_iterator cbegin() const { return const_iterator(d->begin()); }
    inline iterator end() { detach(); return iterator(d->end()); }
    inline const_iterator end() const { return const_iterator(d->end()); }
    inline const_iterator constEnd() const { return const_iterator(d->end()); }
    inline const_iterator cend() const { return const_iterator(d->end()); }
    inline key_iterator keyBegin() const { return key_iterator(begin()); }
    inline key_iterator keyEnd() const { return key_iterator(end()); }
    inline key_value_iterator keyValueBegin() { return key_value_iterator(begin()); }
    inline key_value_iterator keyValueEnd() { return key_value_iterator(end()); }
    inline const_key_value_iterator keyValueBegin() const { return const_key_value_iterator(begin()); }
    inline const_key_value_iterator constKeyValueBegin() const { return const_key_value_iterator(begin()); }
    inline const_key_value_iterator keyValueEnd() const { return const_key_value_iterator(end()); }
    inline const_key_value_iterator constKeyValueEnd() const { return const_key_value_iterator(end()); }
    iterator erase(iterator it);

    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return d->size; }
    iterator find(const Key &key);
    const_iterator find(const Key &key) const;
    const_iterator constFind(const Key &key) const;
    iterator lowerBound(const Key &key);
    const_iterator lowerBound(const Key &key) const;
    iterator upperBound(const Key &key);
    const_iterator upperBound(const Key &key) const;
    iterator insert(const Key &key, const T &value);
    iterator insert(const_iterator pos, const Key &key, const T &value);
    void insert(const QMap<Key, T> &map);




#line 596 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"

    
    typedef Key key_type;
    typedef T mapped_type;
    typedef qptrdiff difference_type;
    typedef int size_type;
    inline bool empty() const { return isEmpty(); }
    QPair<iterator, iterator> equal_range(const Key &akey);
    QPair<const_iterator, const_iterator> equal_range(const Key &akey) const;





private:
    void detach_helper();
    bool isValidIterator(const const_iterator &ci) const
    {

        const QMapNodeBase *n = ci.i;
        while (n->parent())
            n = n->parent();
        return n->left == d->root();



#line 623 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"
    }

    friend class QMultiMap<Key, T>;
};

template <class Key, class T>
inline QMap<Key, T>::QMap(const QMap<Key, T> &other)
{
    if (other.d->ref.ref()) {
        d = other.d;
    } else {
        d = QMapData<Key, T>::create();
        if (other.d->header.left) {
            d->header.left = static_cast<Node *>(other.d->header.left)->copy(d);
            d->header.left->setParent(&d->header);
            d->recalcMostLeftNode();
        }
    }
}

template <class Key, class T>
inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other)
{
    if (d != other.d) {
        QMap<Key, T> tmp(other);
        tmp.swap(*this);
    }
    return *this;
}

template <class Key, class T>
inline void QMap<Key, T>::clear()
{
    *this = QMap<Key, T>();
}

__pragma(warning(push))


template <class Key, class T>
inline const T QMap<Key, T>::value(const Key &akey, const T &adefaultValue) const
{
    Node *n = d->findNode(akey);
    return n ? n->value : adefaultValue;
}

__pragma(warning(pop))

template <class Key, class T>
inline const T QMap<Key, T>::operator[](const Key &akey) const
{
    return value(akey);
}

template <class Key, class T>
inline T &QMap<Key, T>::operator[](const Key &akey)
{
    detach();
    Node *n = d->findNode(akey);
    if (!n)
        return *insert(akey, T());
    return n->value;
}

template <class Key, class T>
inline int QMap<Key, T>::count(const Key &akey) const
{
    Node *firstNode;
    Node *lastNode;
    d->nodeRange(akey, &firstNode, &lastNode);

    const_iterator ci_first(firstNode);
    const const_iterator ci_last(lastNode);
    int cnt = 0;
    while (ci_first != ci_last) {
        ++cnt;
        ++ci_first;
    }
    return cnt;
}

template <class Key, class T>
inline bool QMap<Key, T>::contains(const Key &akey) const
{
    return d->findNode(akey) != nullptr;
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey, const T &avalue)
{
    detach();
    Node *n = d->root();
    Node *y = d->end();
    Node *lastNode = nullptr;
    bool  left = true;
    while (n) {
        y = n;
        if (!qMapLessThanKey(n->key, akey)) {
            lastNode = n;
            left = true;
            n = n->leftNode();
        } else {
            left = false;
            n = n->rightNode();
        }
    }
    if (lastNode && !qMapLessThanKey(akey, lastNode->key)) {
        lastNode->value = avalue;
        return iterator(lastNode);
    }
    Node *z = d->createNode(akey, avalue, y, left);
    return iterator(z);
}

template <class Key, class T>
typename QMap<Key, T>::iterator QMap<Key, T>::insert(const_iterator pos, const Key &akey, const T &avalue)
{
    if (d->ref.isShared())
        return this->insert(akey, avalue);

    ((isValidIterator(pos)) ? static_cast<void>(0) : qt_assert_x("QMap::insert", "The specified const_iterator argument 'it' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 743));

    if (pos == constEnd()) {
        
        Node *n = static_cast<Node *>(pos.i->left);
        if (n) {
            while (n->right)
                n = static_cast<Node *>(n->right);

            if (!qMapLessThanKey(n->key, akey))
                return this->insert(akey, avalue); 
            
            
            

            Node *z = d->createNode(akey, avalue, n, false); 
            return iterator(z);
        }
        return this->insert(akey, avalue);
    } else {
        
        
        Node *next = const_cast<Node*>(pos.i);
        if (qMapLessThanKey(next->key, akey))
            return this->insert(akey, avalue); 

        if (pos == constBegin()) {
            
            
            if (!qMapLessThanKey(akey, next->key)) {
                next->value = avalue; 
                return iterator(next);
            }
            
            Node *z = d->createNode(akey, avalue, begin().i, true);
            return iterator(z);
        } else {
            Node *prev = const_cast<Node*>(pos.i->previousNode());
            if (!qMapLessThanKey(prev->key, akey)) {
                return this->insert(akey, avalue); 
            }
            
            if (!qMapLessThanKey(akey, next->key)) {
                next->value = avalue; 
                return iterator(next);
            }

            
            if (prev->right == nullptr) {
                Node *z = d->createNode(akey, avalue, prev, false);
                return iterator(z);
            }
            if (next->left == nullptr) {
                Node *z = d->createNode(akey, avalue, next, true);
                return iterator(z);
            }
            ((false) ? static_cast<void>(0) : qt_assert("false", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 799)); 
            return this->insert(akey, avalue);
        }
    }
}

template <class Key, class T>
inline void QMap<Key, T>::insert(const QMap<Key, T> &map)
{
    if (d == map.d)
        return;

    detach();

    Node *n = d->root();
    auto it = map.cbegin();
    const auto e = map.cend();
    while (it != e) {
        
        auto parent = d->end();
        bool left = true;
        Node *lastNode = nullptr;
        while (n) {
            parent = n;
            if (!qMapLessThanKey(n->key, it.key())) {
                lastNode = n;
                n = n->leftNode();
                left = true;
            } else {
                n = n->rightNode();
                left = false;
            }
        }
        if (lastNode && !qMapLessThanKey(it.key(), lastNode->key)) {
            lastNode->value = it.value();
            n = lastNode;
        } else {
            n = d->createNode(it.key(), it.value(), parent, left);
        }
        ++it;
        if (it != e) {
            
            
            while (n != d->root() && qMapLessThanKey(n->key, it.key()))
                n = static_cast<Node *>(n->parent());
        }
    }
}


template <class Key, class T>
inline typename QMap<Key, T>::const_iterator QMap<Key, T>::constFind(const Key &akey) const
{
    Node *n = d->findNode(akey);
    return const_iterator(n ? n : d->end());
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator QMap<Key, T>::find(const Key &akey) const
{
    return constFind(akey);
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::find(const Key &akey)
{
    detach();
    Node *n = d->findNode(akey);
    return iterator(n ? n : d->end());
}

template <class Key, class T>
QPair<typename QMap<Key, T>::iterator, typename QMap<Key, T>::iterator> QMap<Key, T>::equal_range(const Key &akey)
{
    detach();
    Node *firstNode, *lastNode;
    d->nodeRange(akey, &firstNode, &lastNode);
    return QPair<iterator, iterator>(iterator(firstNode), iterator(lastNode));
}

template <class Key, class T>
QPair<typename QMap<Key, T>::const_iterator, typename QMap<Key, T>::const_iterator>
QMap<Key, T>::equal_range(const Key &akey) const
{
    Node *firstNode, *lastNode;
    d->nodeRange(akey, &firstNode, &lastNode);
    return qMakePair(const_iterator(firstNode), const_iterator(lastNode));
}























template <class Key, class T>
inline int QMap<Key, T>::remove(const Key &akey)
{
    detach();
    int n = 0;
    while (Node *node = d->findNode(akey)) {
        d->deleteNode(node);
        ++n;
    }
    return n;
}

template <class Key, class T>
inline T QMap<Key, T>::take(const Key &akey)
{
    detach();

    Node *node = d->findNode(akey);
    if (node) {
        T t = std::move(node->value);
        d->deleteNode(node);
        return t;
    }
    return T();
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::erase(iterator it)
{
    if (it == iterator(d->end()))
        return it;

    ((isValidIterator(const_iterator(it))) ? static_cast<void>(0) : qt_assert_x("QMap::erase", "The specified iterator argument 'it' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 942));

    if (d->ref.isShared()) {
        const_iterator oldBegin = constBegin();
        const_iterator old = const_iterator(it);
        int backStepsWithSameKey = 0;

        while (old != oldBegin) {
            --old;
            if (qMapLessThanKey(old.key(), it.key()))
                break;
            ++backStepsWithSameKey;
        }

        it = find(old.key()); 
        ((it != iterator(d->end())) ? static_cast<void>(0) : qt_assert_x("QMap::erase", "Unable to locate same key in erase after detach.", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 957));

        while (backStepsWithSameKey > 0) {
            ++it;
            --backStepsWithSameKey;
        }
    }

    Node *n = it.i;
    ++it;
    d->deleteNode(n);
    return it;
}

template <class Key, class T>
inline void QMap<Key, T>::detach_helper()
{
    QMapData<Key, T> *x = QMapData<Key, T>::create();
    if (d->header.left) {
        x->header.left = static_cast<Node *>(d->header.left)->copy(x);
        x->header.left->setParent(&x->header);
    }
    if (!d->ref.deref())
        d->destroy();
    d = x;
    d->recalcMostLeftNode();
}

template <class Key, class T>
inline QList<Key> QMap<Key, T>::keys() const
{
    QList<Key> res;
    res.reserve(size());
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
inline QList<Key> QMap<Key, T>::keys(const T &avalue) const
{
    QList<Key> res;
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            res.append(i.key());
        ++i;
    }
    return res;
}

template <class Key, class T>
inline const Key QMap<Key, T>::key(const T &avalue, const Key &defaultKey) const
{
    const_iterator i = begin();
    while (i != end()) {
        if (i.value() == avalue)
            return i.key();
        ++i;
    }

    return defaultKey;
}

template <class Key, class T>
inline QList<T> QMap<Key, T>::values() const
{
    QList<T> res;
    res.reserve(size());
    const_iterator i = begin();
    while (i != end()) {
        res.append(i.value());
        ++i;
    }
    return res;
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator QMap<Key, T>::lowerBound(const Key &akey) const
{
    Node *lb = d->root() ? d->root()->lowerBound(akey) : nullptr;
    if (!lb)
        lb = d->end();
    return const_iterator(lb);
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::lowerBound(const Key &akey)
{
    detach();
    Node *lb = d->root() ? d->root()->lowerBound(akey) : nullptr;
    if (!lb)
        lb = d->end();
    return iterator(lb);
}

template <class Key, class T>
inline typename QMap<Key, T>::const_iterator
QMap<Key, T>::upperBound(const Key &akey) const
{
    Node *ub = d->root() ? d->root()->upperBound(akey) : nullptr;
    if (!ub)
        ub = d->end();
    return const_iterator(ub);
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMap<Key, T>::upperBound(const Key &akey)
{
    detach();
    Node *ub = d->root() ? d->root()->upperBound(akey) : nullptr;
    if (!ub)
        ub = d->end();
    return iterator(ub);
}

template <class Key, class T>
inline bool QMap<Key, T>::operator==(const QMap<Key, T> &other) const
{
    if (size() != other.size())
        return false;
    if (d == other.d)
        return true;

    const_iterator it1 = begin();
    const_iterator it2 = other.begin();

    while (it1 != end()) {
        if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
            return false;
        ++it2;
        ++it1;
    }
    return true;
}

template <class Key, class T>
inline QMap<Key, T>::QMap(const std::map<Key, T> &other)
{
    d = QMapData<Key, T>::create();
    typename std::map<Key,T>::const_iterator it = other.end();
    while (it != other.begin()) {
        --it;
        d->createNode((*it).first, (*it).second, d->begin(), true); 
    }
}

template <class Key, class T>
inline std::map<Key, T> QMap<Key, T>::toStdMap() const
{
    std::map<Key, T> map;
    const_iterator it = end();
    while (it != begin()) {
        --it;
        map.insert(map.begin(), std::pair<Key, T>(it.key(), it.value()));
    }
    return map;
}

template <class Key, class T>
class QMultiMap : public QMap<Key, T>
{
public:
    QMultiMap() noexcept {}
    inline QMultiMap(std::initializer_list<std::pair<Key,T> > list)
    {
        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
            insert(it->first, it->second);
    }
    QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {}
    QMultiMap(QMap<Key, T> &&other) noexcept : QMap<Key, T>(std::move(other)) {}
    void swap(QMultiMap<Key, T> &other) noexcept { QMap<Key, T>::swap(other); }

    QList<Key> uniqueKeys() const;
    QList<T> values(const Key &key) const;

    inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value)
    { return QMap<Key, T>::insert(key, value); }
    typename QMap<Key, T>::iterator insert(const Key &key, const T &value);
    
    typename QMap<Key, T>::iterator insert(typename QMap<Key, T>::const_iterator pos,
                                           const Key &key, const T &value);

    
    QMultiMap &unite(const QMultiMap &other);
    inline QMultiMap &operator+=(const QMultiMap &other)
    { return unite(other); }
    inline QMultiMap operator+(const QMultiMap &other) const
    { QMultiMap result = *this; result += other; return result; }

    using QMap<Key, T>::contains;
    using QMap<Key, T>::remove;
    using QMap<Key, T>::count;
    using QMap<Key, T>::find;
    using QMap<Key, T>::constFind;
    using QMap<Key, T>::values;
    using QMap<Key, T>::size;
    using QMap<Key, T>::detach;
    using QMap<Key, T>::erase;
    using QMap<Key, T>::isValidIterator;
    using typename QMap<Key, T>::Node;

    bool contains(const Key &key, const T &value) const;

    int remove(const Key &key, const T &value);

    int count(const Key &key, const T &value) const;

    typename QMap<Key, T>::iterator find(const Key &key, const T &value) {
        typename QMap<Key, T>::iterator i(find(key));
        typename QMap<Key, T>::iterator end(this->end());
        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QMap<Key, T>::const_iterator find(const Key &key, const T &value) const {
        typename QMap<Key, T>::const_iterator i(constFind(key));
        typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
            if (i.value() == value)
                return i;
            ++i;
        }
        return end;
    }
    typename QMap<Key, T>::const_iterator constFind(const Key &key, const T &value) const
        { return find(key, value); }
private:
    T &operator[](const Key &key);
    const T operator[](const Key &key) const;
};

template <class Key, class T>
inline QList<Key> QMultiMap<Key, T>::uniqueKeys() const
{
    QList<Key> res;
    res.reserve(size()); 
    typename QMap<Key, T>::const_iterator i = this->begin();
    if (i != this->end()) {
        for (;;) {
            const Key &aKey = i.key();
            res.append(aKey);
            do {
                if (++i == this->end())
                    goto break_out_of_outer_loop;
            } while (!qMapLessThanKey(aKey, i.key()));   
        }
    }
break_out_of_outer_loop:
    return res;
}

template <class Key, class T>
inline QList<T> QMultiMap<Key, T>::values(const Key &akey) const
{
    QList<T> res;
    Node *n = this->d->findNode(akey);
    if (n) {
        typename QMap<Key, T>::const_iterator it(n);
        do {
            res.append(*it);
            ++it;
        } while (it != this->constEnd() && !qMapLessThanKey<Key>(akey, it.key()));
    }
    return res;
}

template <class Key, class T>
inline typename QMap<Key, T>::iterator QMultiMap<Key, T>::insert(const Key &akey,
                                                                            const T &avalue)
{
    detach();
    Node* y = this->d->end();
    Node* x = static_cast<Node *>(this->d->root());
    bool left = true;
    while (x != nullptr) {
        left = !qMapLessThanKey(x->key, akey);
        y = x;
        x = left ? x->leftNode() : x->rightNode();
    }
    Node *z = this->d->createNode(akey, avalue, y, left);
    return typename QMap<Key, T>::iterator(z);
}


template <class Key, class T>
typename QMap<Key, T>::iterator QMultiMap<Key, T>::insert(typename QMap<Key, T>::const_iterator pos,
                                                          const Key &akey, const T &avalue)
{
    if (this->d->ref.isShared())
        return insert(akey, avalue);

    ((isValidIterator(pos)) ? static_cast<void>(0) : qt_assert_x("QMap::insert", "The specified const_iterator argument 'pos' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1255));

    if (pos == this->constEnd()) {
        
        Node *n = static_cast<Node *>(pos.i->left);
        if (n) {
            while (n->right)
                n = static_cast<Node *>(n->right);

            if (!qMapLessThanKey(n->key, akey))
                return insert(akey, avalue); 
            Node *z = this->d->createNode(akey, avalue, n, false); 
            return typename QMap<Key, T>::iterator(z);
        }
        return insert(akey, avalue);
    } else {
        
        
        Node *next = const_cast<Node*>(pos.i);
        if (qMapLessThanKey(next->key, akey))
            return insert(akey, avalue); 

        if (pos == this->constBegin()) {
            
            Node *z = this->d->createNode(akey, avalue, this->begin().i, true);
            return typename QMap<Key, T>::iterator(z);
        } else {
            Node *prev = const_cast<Node*>(pos.i->previousNode());
            if (!qMapLessThanKey(prev->key, akey))
                return insert(akey, avalue); 

            
            if (prev->right == nullptr) {
                Node *z = this->d->createNode(akey, avalue, prev, false);
                return typename QMap<Key, T>::iterator(z);
            }
            if (next->left == nullptr) {
                Node *z = this->d->createNode(akey, avalue, next, true);
                return typename QMap<Key, T>::iterator(z);
            }
            ((false) ? static_cast<void>(0) : qt_assert("false", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1295)); 
            return insert(akey, avalue);
        }
    }
}

template <class Key, class T>
inline QMultiMap<Key, T> &QMultiMap<Key, T>::unite(const QMultiMap<Key, T> &other)
{
    QMultiMap<Key, T> copy(other);
    typename QMap<Key, T>::const_iterator it = copy.constEnd();
    const typename QMap<Key, T>::const_iterator b = copy.constBegin();
    while (it != b) {
        --it;
        insert(it.key(), it.value());
    }
    return *this;
}
#line 1314 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"

template <class Key, class T>
inline bool QMultiMap<Key, T>::contains(const Key &key, const T &value) const
{
    return constFind(key, value) != QMap<Key, T>::constEnd();
}

template <class Key, class T>
inline int QMultiMap<Key, T>::remove(const Key &key, const T &value)
{
    int n = 0;
    typename QMap<Key, T>::iterator i(find(key));
    typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
        if (i.value() == value) {
            i = erase(i);
            ++n;
        } else {
            ++i;
        }
    }
    return n;
}

template <class Key, class T>
inline int QMultiMap<Key, T>::count(const Key &key, const T &value) const
{
    int n = 0;
    typename QMap<Key, T>::const_iterator i(constFind(key));
    typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
        if (i.value() == value)
            ++n;
        ++i;
    }
    return n;
}































#line 1383 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"

template <class Key, class T> class QMapIterator { typedef typename QMap<Key,T>::const_iterator const_iterator; QMap<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: typedef const_iterator Item; inline QMapIterator(const QMap<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QMapIterator &operator=(const QMap<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1384)); return *n; } inline const Key &key() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1384)); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } };
template <class Key, class T> class QMutableMapIterator { typedef typename QMap<Key,T>::iterator iterator; typedef typename QMap<Key,T>::const_iterator const_iterator; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: typedef iterator Item; inline QMutableMapIterator(QMap<Key,T> &container) : c(&container) { i = c->begin(); n = c->end(); } inline QMutableMapIterator &operator=(QMap<Key,T> &container) { c = &container; i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1385)); return *n; } inline const T &value() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1385)); return *n; } inline const Key &key() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h", 1385)); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };



#line 1390 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmap.h"
#pragma external_header(pop)
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtextstream.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"












































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"













































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"













































#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs_impl.h"
















































#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs_impl.h"


class QObject;

namespace QtPrivate {
    template <typename T> struct RemoveRef { typedef T Type; };
    template <typename T> struct RemoveRef<T&> { typedef T Type; };
    template <typename T> struct RemoveConstRef { typedef T Type; };
    template <typename T> struct RemoveConstRef<const T&> { typedef T Type; };

    





    
    template <typename...> struct List {};
    template <typename Head, typename... Tail> struct List<Head, Tail...> { typedef Head Car; typedef List<Tail...> Cdr; };
    template <typename, typename> struct List_Append;
    template <typename... L1, typename...L2> struct List_Append<List<L1...>, List<L2...>> { typedef List<L1..., L2...> Value; };
    template <typename L, int N> struct List_Left {
        typedef typename List_Append<List<typename L::Car>,typename List_Left<typename L::Cdr, N - 1>::Value>::Value Value;
    };
    template <typename L> struct List_Left<L, 0> { typedef List<> Value; };
    
    template <typename L, int N> struct List_Select { typedef typename List_Select<typename L::Cdr, N - 1>::Value Value; };
    template <typename L> struct List_Select<L,0> { typedef typename L::Car Value; };

    





    template <typename T>
    struct ApplyReturnValue {
        void *data;
        explicit ApplyReturnValue(void *data_) : data(data_) {}
    };
    template<typename T, typename U>
    void operator,(T &&value, const ApplyReturnValue<U> &container) {
        if (container.data)
            *reinterpret_cast<U *>(container.data) = std::forward<T>(value);
    }
    template<typename T>
    void operator,(T, const ApplyReturnValue<void> &) {}


    















    template<class T> using InvokeGenSeq = typename T::Type;

    template<int...> struct IndexesList { using Type = IndexesList; };

    template<int N, class S1, class S2> struct ConcatSeqImpl;

    template<int N, int... I1, int... I2>
    struct ConcatSeqImpl<N, IndexesList<I1...>, IndexesList<I2...>>
        : IndexesList<I1..., (N + I2)...>{};

    template<int N, class S1, class S2>
    using ConcatSeq = InvokeGenSeq<ConcatSeqImpl<N, S1, S2>>;

    template<int N> struct GenSeq;
    template<int N> using makeIndexSequence = InvokeGenSeq<GenSeq<N>>;

    template<int N>
    struct GenSeq : ConcatSeq<N/2, makeIndexSequence<N/2>, makeIndexSequence<N - N/2>>{};

    template<> struct GenSeq<0> : IndexesList<>{};
    template<> struct GenSeq<1> : IndexesList<0>{};

    template<int N>
    struct Indexes { using Value = makeIndexSequence<N>; };

    template<typename Func> struct FunctionPointer { enum {ArgumentCount = -1, IsPointerToMemberFunction = false}; };

    template <typename, typename, typename, typename> struct FunctorCall;
    template <int... II, typename... SignalArgs, typename R, typename Function>
    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, Function> {
        static void call(Function &f, void **arg) {
            f((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...), ApplyReturnValue<R>(arg[0]);
        }
    };
    template <int... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...)> {
        static void call(SlotRet (Obj::*f)(SlotArgs...), Obj *o, void **arg) {
            (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...), ApplyReturnValue<R>(arg[0]);
        }
    };
    template <int... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) const> {
        static void call(SlotRet (Obj::*f)(SlotArgs...) const, Obj *o, void **arg) {
            (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...), ApplyReturnValue<R>(arg[0]);
        }
    };

    template <int... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) noexcept> {
        static void call(SlotRet (Obj::*f)(SlotArgs...) noexcept, Obj *o, void **arg) {
            (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...), ApplyReturnValue<R>(arg[0]);
        }
    };
    template <int... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) const noexcept> {
        static void call(SlotRet (Obj::*f)(SlotArgs...) const noexcept, Obj *o, void **arg) {
            (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...), ApplyReturnValue<R>(arg[0]);
        }
    };
#line 175 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs_impl.h"

    template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...)>
    {
        typedef Obj Object;
        typedef List<Args...>  Arguments;
        typedef Ret ReturnType;
        typedef Ret (Obj::*Function) (Args...);
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
        template <typename SignalArgs, typename R>
        static void call(Function f, Obj *o, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, o, arg);
        }
    };
    template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) const>
    {
        typedef Obj Object;
        typedef List<Args...>  Arguments;
        typedef Ret ReturnType;
        typedef Ret (Obj::*Function) (Args...) const;
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
        template <typename SignalArgs, typename R>
        static void call(Function f, Obj *o, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, o, arg);
        }
    };

    template<typename Ret, typename... Args> struct FunctionPointer<Ret (*) (Args...)>
    {
        typedef List<Args...> Arguments;
        typedef Ret ReturnType;
        typedef Ret (*Function) (Args...);
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = false};
        template <typename SignalArgs, typename R>
        static void call(Function f, void *, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, arg);
        }
    };


    template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) noexcept>
    {
        typedef Obj Object;
        typedef List<Args...>  Arguments;
        typedef Ret ReturnType;
        typedef Ret (Obj::*Function) (Args...) noexcept;
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
        template <typename SignalArgs, typename R>
        static void call(Function f, Obj *o, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, o, arg);
        }
    };
    template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) const noexcept>
    {
        typedef Obj Object;
        typedef List<Args...>  Arguments;
        typedef Ret ReturnType;
        typedef Ret (Obj::*Function) (Args...) const noexcept;
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
        template <typename SignalArgs, typename R>
        static void call(Function f, Obj *o, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, o, arg);
        }
    };

    template<typename Ret, typename... Args> struct FunctionPointer<Ret (*) (Args...) noexcept>
    {
        typedef List<Args...> Arguments;
        typedef Ret ReturnType;
        typedef Ret (*Function) (Args...) noexcept;
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = false};
        template <typename SignalArgs, typename R>
        static void call(Function f, void *, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, arg);
        }
    };
#line 251 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs_impl.h"

    template<typename Function, int N> struct Functor
    {
        template <typename SignalArgs, typename R>
        static void call(Function &f, void *, void **arg) {
            FunctorCall<typename Indexes<N>::Value, SignalArgs, R, Function>::call(f, arg);
        }
    };

    





    template<typename E, typename Enable = void>
    struct IsEnumUnderlyingTypeSigned : std::false_type
    {
    };

    template<typename E>
    struct IsEnumUnderlyingTypeSigned<E, typename std::enable_if<std::is_enum<E>::value>::type>
            : std::integral_constant<bool, std::is_signed<typename std::underlying_type<E>::type>::value>
    {
    };

    





    template<typename From, typename To, typename Enable = void>
    struct AreArgumentsNarrowedBase : std::false_type
    {
    };

    template <typename T>
    using is_bool = std::is_same<bool, typename std::decay<T>::type>;

    template<typename From, typename To>
    struct AreArgumentsNarrowedBase<From, To, typename std::enable_if<sizeof(From) && sizeof(To)>::type>
        : std::integral_constant<bool,
              (std::is_floating_point<From>::value && std::is_integral<To>::value) ||
              (std::is_floating_point<From>::value && std::is_floating_point<To>::value && sizeof(From) > sizeof(To)) ||
              ((std::is_pointer<From>::value || std::is_member_pointer<From>::value) && QtPrivate::is_bool<To>::value) ||
              ((std::is_integral<From>::value || std::is_enum<From>::value) && std::is_floating_point<To>::value) ||
              (std::is_integral<From>::value && std::is_integral<To>::value
               && (sizeof(From) > sizeof(To)
                   || (std::is_signed<From>::value ? !std::is_signed<To>::value
                       : (std::is_signed<To>::value && sizeof(From) == sizeof(To))))) ||
              (std::is_enum<From>::value && std::is_integral<To>::value
               && (sizeof(From) > sizeof(To)
                   || (IsEnumUnderlyingTypeSigned<From>::value ? !std::is_signed<To>::value
                       : (std::is_signed<To>::value && sizeof(From) == sizeof(To)))))
              >
    {
    };

    




    template<typename A1, typename A2> struct AreArgumentsCompatible {
        static int test(const typename RemoveRef<A2>::Type&);
        static char test(...);
        static const typename RemoveRef<A1>::Type &dummy();
        enum { value = sizeof(test(dummy())) == sizeof(int) };




    };
    template<typename A1, typename A2> struct AreArgumentsCompatible<A1, A2&> { enum { value = false }; };
    template<typename A> struct AreArgumentsCompatible<A&, A&> { enum { value = true }; };
    
    template<typename A> struct AreArgumentsCompatible<void, A> { enum { value = true }; };
    template<typename A> struct AreArgumentsCompatible<A, void> { enum { value = true }; };
    template<> struct AreArgumentsCompatible<void, void> { enum { value = true }; };

    template <typename List1, typename List2> struct CheckCompatibleArguments { enum { value = false }; };
    template <> struct CheckCompatibleArguments<List<>, List<>> { enum { value = true }; };
    template <typename List1> struct CheckCompatibleArguments<List1, List<>> { enum { value = true }; };
    template <typename Arg1, typename Arg2, typename... Tail1, typename... Tail2>
    struct CheckCompatibleArguments<List<Arg1, Tail1...>, List<Arg2, Tail2...>>
    {
        enum { value = AreArgumentsCompatible<typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value
                    && CheckCompatibleArguments<List<Tail1...>, List<Tail2...>>::value };
    };

    




    template <typename Functor, typename ArgList> struct ComputeFunctorArgumentCount;

    template <typename Functor, typename ArgList, bool Done> struct ComputeFunctorArgumentCountHelper
    { enum { Value = -1 }; };
    template <typename Functor, typename First, typename... ArgList>
    struct ComputeFunctorArgumentCountHelper<Functor, List<First, ArgList...>, false>
        : ComputeFunctorArgumentCount<Functor,
            typename List_Left<List<First, ArgList...>, sizeof...(ArgList)>::Value> {};

    template <typename Functor, typename... ArgList> struct ComputeFunctorArgumentCount<Functor, List<ArgList...>>
    {
        template <typename D> static D dummy();
        template <typename F> static auto test(F f) -> decltype(((f.operator()((dummy<ArgList>())...)), int()));
        static char test(...);
        enum {
            Ok = sizeof(test(dummy<Functor>())) == sizeof(int),
            Value = Ok ? int(sizeof...(ArgList)) : int(ComputeFunctorArgumentCountHelper<Functor, List<ArgList...>, Ok>::Value)
        };
    };

    
    template <typename Functor, typename ArgList> struct FunctorReturnType;
    template <typename Functor, typename ... ArgList> struct FunctorReturnType<Functor, List<ArgList...>> {
        template <typename D> static D dummy();
        typedef decltype(dummy<Functor>().operator()((dummy<ArgList>())...)) Value;
    };

    
    class QSlotObjectBase {
        QAtomicInt m_ref;
        
        
        
        typedef void (*ImplFn)(int which, QSlotObjectBase* this_, QObject *receiver, void **args, bool *ret);
        const ImplFn m_impl;
    protected:
        enum Operation {
            Destroy,
            Call,
            Compare,

            NumOperations
        };
    public:
        explicit QSlotObjectBase(ImplFn fn) : m_ref(1), m_impl(fn) {}

        inline int ref() noexcept { return m_ref.ref(); }
        inline void destroyIfLastRef() noexcept
        { if (!m_ref.deref()) m_impl(Destroy, this, nullptr, nullptr, nullptr); }

        inline bool compare(void **a) { bool ret = false; m_impl(Compare, this, nullptr, a, &ret); return ret; }
        inline void call(QObject *r, void **a)  { m_impl(Call,    this, r, a, nullptr); }
    protected:
        ~QSlotObjectBase() {}
    private:
        QSlotObjectBase(const QSlotObjectBase &) = delete; QSlotObjectBase &operator=(const QSlotObjectBase &) = delete; QSlotObjectBase(QSlotObjectBase &&) = delete; QSlotObjectBase &operator=(QSlotObjectBase &&) = delete;
    };

    
    
    template<typename Func, typename Args, typename R> class QSlotObject : public QSlotObjectBase
    {
        typedef QtPrivate::FunctionPointer<Func> FuncType;
        Func function;
        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
        {
            switch (which) {
            case Destroy:
                delete static_cast<QSlotObject*>(this_);
                break;
            case Call:
                FuncType::template call<Args, R>(static_cast<QSlotObject*>(this_)->function, static_cast<typename FuncType::Object *>(r), a);
                break;
            case Compare:
                *ret = *reinterpret_cast<Func *>(a) == static_cast<QSlotObject*>(this_)->function;
                break;
            case NumOperations: ;
            }
        }
    public:
        explicit QSlotObject(Func f) : QSlotObjectBase(&impl), function(f) {}
    };
    
    
    
    template<typename Func, int N, typename Args, typename R> class QFunctorSlotObject : public QSlotObjectBase
    {
        typedef QtPrivate::Functor<Func, N> FuncType;
        Func function;
        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
        {
            switch (which) {
            case Destroy:
                delete static_cast<QFunctorSlotObject*>(this_);
                break;
            case Call:
                FuncType::template call<Args, R>(static_cast<QFunctorSlotObject*>(this_)->function, r, a);
                break;
            case Compare: 
            case NumOperations:
                (void)ret;;
            }
        }
    public:
        explicit QFunctorSlotObject(Func f) : QSlotObjectBase(&impl), function(std::move(f)) {}
    };

    
    template <typename Func>
    using QSlotObjectWithNoArgs = QSlotObject<Func,
                                              QtPrivate::List<>,
                                              typename QtPrivate::FunctionPointer<Func>::ReturnType>;

    template <typename Func, typename R>
    using QFunctorSlotObjectWithNoArgs = QFunctorSlotObject<Func, 0, QtPrivate::List<>, R>;

    template <typename Func>
    using QFunctorSlotObjectWithNoArgsImplicitReturn = QFunctorSlotObjectWithNoArgs<Func, typename QtPrivate::FunctionPointer<Func>::ReturnType>;
}



#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"




class QByteArray;
struct QArrayData;
typedef QArrayData QByteArrayData;

class QString;


#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"





#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"


#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"


#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"


#line 78 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"













#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"









#line 102 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"






#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"


















#line 128 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"











#line 140 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"











#line 152 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

#line 154 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"



#line 158 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

#line 160 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

#line 162 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"



#line 166 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

#line 168 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"














































#line 215 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"


























#line 242 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"












#line 255 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

__declspec(dllimport) const char *qFlagLocation(const char *method);















#line 273 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"




#line 278 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"




class QObject;
class QMetaMethod;
class QMetaEnum;
class QMetaProperty;
class QMetaClassInfo;


class __declspec(dllimport) QGenericArgument
{
public:
    inline QGenericArgument(const char *aName = nullptr, const void *aData = nullptr)
        : _data(aData), _name(aName) {}
    inline void *data() const { return const_cast<void *>(_data); }
    inline const char *name() const { return _name; }

private:
    const void *_data;
    const char *_name;
};

class __declspec(dllimport) QGenericReturnArgument: public QGenericArgument
{
public:
    inline QGenericReturnArgument(const char *aName = nullptr, void *aData = nullptr)
        : QGenericArgument(aName, aData)
        {}
};

template <class T>
class QArgument: public QGenericArgument
{
public:
    inline QArgument(const char *aName, const T &aData)
        : QGenericArgument(aName, static_cast<const void *>(&aData))
        {}
};
template <class T>
class QArgument<T &>: public QGenericArgument
{
public:
    inline QArgument(const char *aName, T &aData)
        : QGenericArgument(aName, static_cast<const void *>(&aData))
        {}
};


template <typename T>
class QReturnArgument: public QGenericReturnArgument
{
public:
    inline QReturnArgument(const char *aName, T &aData)
        : QGenericReturnArgument(aName, static_cast<void *>(&aData))
        {}
};

struct __declspec(dllimport) QMetaObject
{
    class Connection;
    const char *className() const;
    const QMetaObject *superClass() const;

    bool inherits(const QMetaObject *metaObject) const noexcept;
    QObject *cast(QObject *obj) const;
    const QObject *cast(const QObject *obj) const;


    QString tr(const char *s, const char *c, int n = -1) const;
#line 350 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

    int methodOffset() const;
    int enumeratorOffset() const;
    int propertyOffset() const;
    int classInfoOffset() const;

    int constructorCount() const;
    int methodCount() const;
    int enumeratorCount() const;
    int propertyCount() const;
    int classInfoCount() const;

    int indexOfConstructor(const char *constructor) const;
    int indexOfMethod(const char *method) const;
    int indexOfSignal(const char *signal) const;
    int indexOfSlot(const char *slot) const;
    int indexOfEnumerator(const char *name) const;
    int indexOfProperty(const char *name) const;
    int indexOfClassInfo(const char *name) const;

    QMetaMethod constructor(int index) const;
    QMetaMethod method(int index) const;
    QMetaEnum enumerator(int index) const;
    QMetaProperty property(int index) const;
    QMetaClassInfo classInfo(int index) const;
    QMetaProperty userProperty() const;

    static bool checkConnectArgs(const char *signal, const char *method);
    static bool checkConnectArgs(const QMetaMethod &signal,
                                 const QMetaMethod &method);
    static QByteArray normalizedSignature(const char *method);
    static QByteArray normalizedType(const char *type);

    
    static Connection connect(const QObject *sender, int signal_index,
                        const QObject *receiver, int method_index,
                        int type = 0, int *types = nullptr);
    
    static bool disconnect(const QObject *sender, int signal_index,
                           const QObject *receiver, int method_index);
    static bool disconnectOne(const QObject *sender, int signal_index,
                              const QObject *receiver, int method_index);
    
    static void connectSlotsByName(QObject *o);

    
    static void activate(QObject *sender, int signal_index, void **argv);
    static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv);
    static void activate(QObject *sender, int signal_offset, int local_signal_index, void **argv);

    static bool invokeMethod(QObject *obj, const char *member,
                             Qt::ConnectionType,
                             QGenericReturnArgument ret,
                             QGenericArgument val0 = QGenericArgument(nullptr),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument());

    static inline bool invokeMethod(QObject *obj, const char *member,
                             QGenericReturnArgument ret,
                             QGenericArgument val0 = QGenericArgument(nullptr),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3,
                val4, val5, val6, val7, val8, val9);
    }

    static inline bool invokeMethod(QObject *obj, const char *member,
                             Qt::ConnectionType type,
                             QGenericArgument val0 = QGenericArgument(nullptr),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2,
                                 val3, val4, val5, val6, val7, val8, val9);
    }

    static inline bool invokeMethod(QObject *obj, const char *member,
                             QGenericArgument val0 = QGenericArgument(nullptr),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0,
                val1, val2, val3, val4, val5, val6, val7, val8, val9);
    }








    
    template <typename Func>
    static typename std::enable_if<QtPrivate::FunctionPointer<Func>::IsPointerToMemberFunction
                                   && !std::is_convertible<Func, const char*>::value
                                   && QtPrivate::FunctionPointer<Func>::ArgumentCount == 0, bool>::type
    invokeMethod(typename QtPrivate::FunctionPointer<Func>::Object *object,
                 Func function,
                 Qt::ConnectionType type = Qt::AutoConnection,
                 typename QtPrivate::FunctionPointer<Func>::ReturnType *ret = nullptr)
    {
        return invokeMethodImpl(object, new QtPrivate::QSlotObjectWithNoArgs<Func>(function), type, ret);
    }

    template <typename Func>
    static typename std::enable_if<QtPrivate::FunctionPointer<Func>::IsPointerToMemberFunction
                                   && !std::is_convertible<Func, const char*>::value
                                   && QtPrivate::FunctionPointer<Func>::ArgumentCount == 0, bool>::type
    invokeMethod(typename QtPrivate::FunctionPointer<Func>::Object *object,
                 Func function,
                 typename QtPrivate::FunctionPointer<Func>::ReturnType *ret)
    {
        return invokeMethodImpl(object, new QtPrivate::QSlotObjectWithNoArgs<Func>(function), Qt::AutoConnection, ret);
    }

    
    template <typename Func>
    static typename std::enable_if<!QtPrivate::FunctionPointer<Func>::IsPointerToMemberFunction
                                   && !std::is_convertible<Func, const char*>::value
                                   && QtPrivate::FunctionPointer<Func>::ArgumentCount == 0, bool>::type
    invokeMethod(QObject *context, Func function,
                 Qt::ConnectionType type = Qt::AutoConnection,
                 typename QtPrivate::FunctionPointer<Func>::ReturnType *ret = nullptr)
    {
        return invokeMethodImpl(context, new QtPrivate::QFunctorSlotObjectWithNoArgsImplicitReturn<Func>(function), type, ret);
    }

    template <typename Func>
    static typename std::enable_if<!QtPrivate::FunctionPointer<Func>::IsPointerToMemberFunction
                                   && !std::is_convertible<Func, const char*>::value
                                   && QtPrivate::FunctionPointer<Func>::ArgumentCount == 0, bool>::type
    invokeMethod(QObject *context, Func function,
                 typename QtPrivate::FunctionPointer<Func>::ReturnType *ret)
    {
        return invokeMethodImpl(context, new QtPrivate::QFunctorSlotObjectWithNoArgsImplicitReturn<Func>(function), Qt::AutoConnection, ret);
    }

    
    template <typename Func>
    static typename std::enable_if<!QtPrivate::FunctionPointer<Func>::IsPointerToMemberFunction
                                   && QtPrivate::FunctionPointer<Func>::ArgumentCount == -1
                                   && !std::is_convertible<Func, const char*>::value, bool>::type
    invokeMethod(QObject *context, Func function,
                 Qt::ConnectionType type = Qt::AutoConnection, decltype(function()) *ret = nullptr)
    {
        return invokeMethodImpl(context,
                                new QtPrivate::QFunctorSlotObjectWithNoArgs<Func, decltype(function())>(std::move(function)),
                                type,
                                ret);
    }

    template <typename Func>
    static typename std::enable_if<!QtPrivate::FunctionPointer<Func>::IsPointerToMemberFunction
                                   && QtPrivate::FunctionPointer<Func>::ArgumentCount == -1
                                   && !std::is_convertible<Func, const char*>::value, bool>::type
    invokeMethod(QObject *context, Func function, decltype(function()) *ret)
    {
        return invokeMethodImpl(context,
                                new QtPrivate::QFunctorSlotObjectWithNoArgs<Func, decltype(function())>(std::move(function)),
                                Qt::AutoConnection,
                                ret);
    }

#line 544 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

    QObject *newInstance(QGenericArgument val0 = QGenericArgument(nullptr),
                         QGenericArgument val1 = QGenericArgument(),
                         QGenericArgument val2 = QGenericArgument(),
                         QGenericArgument val3 = QGenericArgument(),
                         QGenericArgument val4 = QGenericArgument(),
                         QGenericArgument val5 = QGenericArgument(),
                         QGenericArgument val6 = QGenericArgument(),
                         QGenericArgument val7 = QGenericArgument(),
                         QGenericArgument val8 = QGenericArgument(),
                         QGenericArgument val9 = QGenericArgument()) const;

    enum Call {
        InvokeMetaMethod,
        ReadProperty,
        WriteProperty,
        ResetProperty,
        QueryPropertyDesignable,
        QueryPropertyScriptable,
        QueryPropertyStored,
        QueryPropertyEditable,
        QueryPropertyUser,
        CreateInstance,
        IndexOfMethod,
        RegisterPropertyMetaType,
        RegisterMethodArgumentMetaType
    };

    int static_metacall(Call, int, void **) const;
    static int metacall(QObject *, Call, int, void **);

    template <const QMetaObject &MO> static constexpr const QMetaObject *staticMetaObject()
    {
        return &MO;
    }

    struct SuperData {
        const QMetaObject *direct;
        SuperData() = default;
        constexpr SuperData(std::nullptr_t) : direct(nullptr) {}
        constexpr SuperData(const QMetaObject *mo) : direct(mo) {}

        constexpr const QMetaObject *operator->() const { return operator const QMetaObject *(); }










        constexpr operator const QMetaObject *() const
        { return direct; }
        template <const QMetaObject &MO> static constexpr SuperData link()
        { return SuperData(QMetaObject::staticMetaObject<MO>()); }
#line 602 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"
    };

    struct { 
        SuperData superdata;
        const QByteArrayData *stringdata;
        const uint *data;
        typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
        StaticMetacallFunction static_metacall;
        const SuperData *relatedMetaObjects;
        void *extradata; 
    } d;

private:
    static bool invokeMethodImpl(QObject *object, QtPrivate::QSlotObjectBase *slot, Qt::ConnectionType type, void *ret);
    friend class QTimer;
};

class __declspec(dllimport) QMetaObject::Connection {
    void *d_ptr; 
    explicit Connection(void *data) : d_ptr(data) {  }
    friend class QObject;
    friend class QObjectPrivate;
    friend struct QMetaObject;
    bool isConnected_helper() const;
public:
    ~Connection();
    Connection();
    Connection(const Connection &other);
    Connection &operator=(const Connection &other);



    typedef void *Connection::*RestrictedBool;
    operator RestrictedBool() const { return d_ptr && isConnected_helper() ? &Connection::d_ptr : nullptr; }
#line 637 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"

    Connection(Connection &&o) noexcept : d_ptr(o.d_ptr) { o.d_ptr = nullptr; }
    Connection &operator=(Connection &&other) noexcept
    { qSwap(d_ptr, other.d_ptr); return *this; }
};

inline const QMetaObject *QMetaObject::superClass() const
{ return d.superdata; }

namespace QtPrivate {
    
    template <typename Object> struct HasQ_OBJECT_Macro {
        template <typename T>
        static char test(int (T::*)(QMetaObject::Call, int, void **));
        static int test(int (Object::*)(QMetaObject::Call, int, void **));
        enum { Value =  sizeof(test(&Object::qt_metacall)) == sizeof(int) };
    };
}



#line 659 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobjectdefs.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"






#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qscopedpointer.h"
















































template <typename T>
struct QScopedPointerDeleter
{
    static inline void cleanup(T *pointer)
    {
        
        
        
        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
        (void) sizeof(IsIncompleteType);

        delete pointer;
    }
};

template <typename T>
struct QScopedPointerArrayDeleter
{
    static inline void cleanup(T *pointer)
    {
        
        
        
        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
        (void) sizeof(IsIncompleteType);

        delete [] pointer;
    }
};

struct QScopedPointerPodDeleter
{
    static inline void cleanup(void *pointer) { if (pointer) free(pointer); }
};


template <typename T>
struct QScopedPointerObjectDeleteLater
{
    static inline void cleanup(T *pointer) { if (pointer) pointer->deleteLater(); }
};

class QObject;
typedef QScopedPointerObjectDeleteLater<QObject> QScopedPointerDeleteLater;
#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qscopedpointer.h"

template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
class QScopedPointer
{
    typedef T *QScopedPointer:: *RestrictedBool;
public:
    explicit QScopedPointer(T *p = nullptr) noexcept : d(p)
    {
    }

    inline ~QScopedPointer()
    {
        T *oldD = this->d;
        Cleanup::cleanup(oldD);
    }

    inline T &operator*() const
    {
        ((d) ? static_cast<void>(0) : qt_assert("d", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qscopedpointer.h", 112));
        return *d;
    }

    T *operator->() const noexcept
    {
        return d;
    }

    bool operator!() const noexcept
    {
        return !d;
    }






#line 132 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qscopedpointer.h"
    operator RestrictedBool() const noexcept
    {
        return isNull() ? nullptr : &QScopedPointer::d;
    }
#line 137 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qscopedpointer.h"

    T *data() const noexcept
    {
        return d;
    }

    T *get() const noexcept
    {
        return d;
    }

    bool isNull() const noexcept
    {
        return !d;
    }

    void reset(T *other = nullptr) noexcept(noexcept(Cleanup::cleanup(std::declval<T *>())))
    {
        if (d == other)
            return;
        T *oldD = d;
        d = other;
        Cleanup::cleanup(oldD);
    }

    T *take() noexcept
    {
        T *oldD = d;
        d = nullptr;
        return oldD;
    }

    void swap(QScopedPointer<T, Cleanup> &other) noexcept
    {
        qSwap(d, other.d);
    }

    typedef T *pointer;

protected:
    T *d;

private:
    QScopedPointer(const QScopedPointer &) = delete; QScopedPointer &operator=(const QScopedPointer &) = delete;
};

template <class T, class Cleanup>
inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs) noexcept
{
    return lhs.data() == rhs.data();
}

template <class T, class Cleanup>
inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs) noexcept
{
    return lhs.data() != rhs.data();
}

template <class T, class Cleanup>
inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t) noexcept
{
    return lhs.isNull();
}

template <class T, class Cleanup>
inline bool operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs) noexcept
{
    return rhs.isNull();
}

template <class T, class Cleanup>
inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t) noexcept
{
    return !lhs.isNull();
}

template <class T, class Cleanup>
inline bool operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs) noexcept
{
    return !rhs.isNull();
}

template <class T, class Cleanup>
inline void swap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2) noexcept
{ p1.swap(p2); }

template <typename T, typename Cleanup = QScopedPointerArrayDeleter<T> >
class QScopedArrayPointer : public QScopedPointer<T, Cleanup>
{
    template <typename Ptr>
    using if_same_type = typename std::enable_if<std::is_same<typename std::remove_cv<T>::type, Ptr>::value, bool>::type;
public:
    inline QScopedArrayPointer() : QScopedPointer<T, Cleanup>(nullptr) {}

    template <typename D, if_same_type<D> = true>
    explicit QScopedArrayPointer(D *p)
        : QScopedPointer<T, Cleanup>(p)
    {
    }

    inline T &operator[](int i)
    {
        return this->d[i];
    }

    inline const T &operator[](int i) const
    {
        return this->d[i];
    }

    void swap(QScopedArrayPointer &other) noexcept 
    { QScopedPointer<T, Cleanup>::swap(other); }

private:
    explicit inline QScopedArrayPointer(void *) {
        

        
        
        

        
        
    }

    QScopedArrayPointer(const QScopedArrayPointer &) = delete; QScopedArrayPointer &operator=(const QScopedArrayPointer &) = delete;
};

template <typename T, typename Cleanup>
inline void swap(QScopedArrayPointer<T, Cleanup> &lhs, QScopedArrayPointer<T, Cleanup> &rhs) noexcept
{ lhs.swap(rhs); }



#line 272 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qscopedpointer.h"
#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"













































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainerfwd.h"















































template <class Key, class T> class QCache;
template <class Key, class T> class QHash;


#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainerfwd.h"
template <class T> class QList;
template <class Key, class T> class QMap;
template <class Key, class T> class QMultiHash;
template <class Key, class T> class QMultiMap;
template <class T1, class T2> struct QPair;
template <class T> class QQueue;
template <class T> class QSet;
template <class T> class QStack;
template<class T, int Prealloc = 256> class QVarLengthArray;
template <class T> class QVector;
using QByteArrayList = QList<QByteArray>;
class QStringList;



#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainerfwd.h"
#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"











































#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"
























































































#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h"













template<class T, int Prealloc>
class QVarLengthArray
{
public:
    QVarLengthArray() : QVarLengthArray(0) {}

    inline explicit QVarLengthArray(int size);

    inline QVarLengthArray(const QVarLengthArray<T, Prealloc> &other)
        : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
    {
        append(other.constData(), other.size());
    }

    QVarLengthArray(std::initializer_list<T> args)
        : QVarLengthArray(args.begin(), args.end())
    {
    }

    template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
    inline QVarLengthArray(InputIterator first, InputIterator last)
        : QVarLengthArray()
    {
        QtPrivate::reserveIfForwardIterator(this, first, last);
        std::copy(first, last, std::back_inserter(*this));
    }

    inline ~QVarLengthArray() {
        if (QTypeInfo<T>::isComplex) {
            T *i = ptr + s;
            while (i-- != ptr)
                i->~T();
        }
        if (ptr != reinterpret_cast<T *>(array))
            free(ptr);
    }
    inline QVarLengthArray<T, Prealloc> &operator=(const QVarLengthArray<T, Prealloc> &other)
    {
        if (this != &other) {
            clear();
            append(other.constData(), other.size());
        }
        return *this;
    }

    QVarLengthArray<T, Prealloc> &operator=(std::initializer_list<T> list)
    {
        resize(int(list.size())); 
        std::copy(list.begin(), list.end(),
                  stdext::make_checked_array_iterator(this->begin(), size_t(this->size())));
        return *this;
    }

    inline void removeLast() {
        ((s > 0) ? static_cast<void>(0) : qt_assert("s > 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 114));
        if (QTypeInfo<T>::isComplex)
            ptr[s - 1].~T();
        --s;
    }
    inline int size() const { return s; }
    inline int count() const { return s; }
    inline int length() const { return s; }
    inline T& first() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 122)); return *begin(); }
    inline const T& first() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 123)); return *begin(); }
    T& last() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 124)); return *(end() - 1); }
    const T& last() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 125)); return *(end() - 1); }
    inline bool isEmpty() const { return (s == 0); }
    inline void resize(int size);
    inline void clear() { resize(0); }
    inline void squeeze();

    inline int capacity() const { return a; }
    inline void reserve(int size);

    inline int indexOf(const T &t, int from = 0) const;
    inline int lastIndexOf(const T &t, int from = -1) const;
    inline bool contains(const T &t) const;

    inline T &operator[](int idx) {
        ((idx >= 0 && idx < s) ? static_cast<void>(0) : qt_assert("idx >= 0 && idx < s", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 139));
        return ptr[idx];
    }
    inline const T &operator[](int idx) const {
        ((idx >= 0 && idx < s) ? static_cast<void>(0) : qt_assert("idx >= 0 && idx < s", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 143));
        return ptr[idx];
    }
    inline const T &at(int idx) const { return operator[](idx); }

    T value(int i) const;
    T value(int i, const T &defaultValue) const;

    inline void append(const T &t) {
        if (s == a) {   
            T copy(t);
            realloc(s, s<<1);
            new (end()) T(std::move(copy));
        } else {
            new (end()) T(t);
        }
        ++s;
    }

    void append(T &&t) {
        if (s == a)
            realloc(s, s << 1);
        new (end()) T(std::move(t));
        ++s;
    }

    void append(const T *buf, int size);
    inline QVarLengthArray<T, Prealloc> &operator<<(const T &t)
    { append(t); return *this; }
    inline QVarLengthArray<T, Prealloc> &operator<<(T &&t)
    { append(std::move(t)); return *this; }
    inline QVarLengthArray<T, Prealloc> &operator+=(const T &t)
    { append(t); return *this; }
    inline QVarLengthArray<T, Prealloc> &operator+=(T &&t)
    { append(std::move(t)); return *this; }

    void prepend(T &&t);
    void prepend(const T &t);
    void insert(int i, T &&t);
    void insert(int i, const T &t);
    void insert(int i, int n, const T &t);
    void replace(int i, const T &t);
    void remove(int i);
    void remove(int i, int n);


    inline T *data() { return ptr; }
    inline const T *data() const { return ptr; }
    inline const T * constData() const { return ptr; }
    typedef int size_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef qptrdiff difference_type;


    typedef T* iterator;
    typedef const T* const_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    inline iterator begin() { return ptr; }
    inline const_iterator begin() const { return ptr; }
    inline const_iterator cbegin() const { return ptr; }
    inline const_iterator constBegin() const { return ptr; }
    inline iterator end() { return ptr + s; }
    inline const_iterator end() const { return ptr + s; }
    inline const_iterator cend() const { return ptr + s; }
    inline const_iterator constEnd() const { return ptr + s; }
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
    iterator insert(const_iterator before, int n, const T &x);
    iterator insert(const_iterator before, T &&x);
    inline iterator insert(const_iterator before, const T &x) { return insert(before, 1, x); }
    iterator erase(const_iterator begin, const_iterator end);
    inline iterator erase(const_iterator pos) { return erase(pos, pos+1); }

    
    inline bool empty() const { return isEmpty(); }
    inline void push_back(const T &t) { append(t); }
    void push_back(T &&t) { append(std::move(t)); }
    inline void pop_back() { removeLast(); }
    inline T &front() { return first(); }
    inline const T &front() const { return first(); }
    inline T &back() { return last(); }
    inline const T &back() const { return last(); }
    void shrink_to_fit() { squeeze(); }

private:
    void realloc(int size, int alloc);

    int a;      
    int s;      
    T *ptr;     
    union {
        char array[Prealloc * sizeof(T)];
        qint64 q_for_alignment_1;
        double q_for_alignment_2;
    };

    bool isValidIterator(const const_iterator &i) const
    {
        const std::less<const T*> less = {};
        return !less(cend(), i) && !less(i, cbegin());
    }
};


template <typename InputIterator,
          typename ValueType = typename std::iterator_traits<InputIterator>::value_type,
          QtPrivate::IfIsInputIterator<InputIterator> = true>
QVarLengthArray(InputIterator, InputIterator) -> QVarLengthArray<ValueType>;
#line 262 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h"

template <class T, int Prealloc>
inline QVarLengthArray<T, Prealloc>::QVarLengthArray(int asize)
    : s(asize) {
    static_assert(bool(Prealloc > 0), "QVarLengthArray Prealloc must be greater than 0.");
    ((s >= 0) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::QVarLengthArray()", "Size must be greater than or equal to 0.", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 267));
    if (s > Prealloc) {
        ptr = reinterpret_cast<T *>(malloc(s * sizeof(T)));
        do { if (!(ptr)) qBadAlloc(); } while (false);
        a = s;
    } else {
        ptr = reinterpret_cast<T *>(array);
        a = Prealloc;
    }
    if (QTypeInfo<T>::isComplex) {
        T *i = ptr + s;
        while (i != ptr)
            new (--i) T;
    }
}

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::resize(int asize)
{ realloc(asize, qMax(asize, a)); }

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::reserve(int asize)
{ if (asize > a) realloc(s, asize); }

template <class T, int Prealloc>
inline int QVarLengthArray<T, Prealloc>::indexOf(const T &t, int from) const
{
    if (from < 0)
        from = qMax(from + s, 0);
    if (from < s) {
        T *n = ptr + from - 1;
        T *e = ptr + s;
        while (++n != e)
            if (*n == t)
                return n - ptr;
    }
    return -1;
}

template <class T, int Prealloc>
inline int QVarLengthArray<T, Prealloc>::lastIndexOf(const T &t, int from) const
{
    if (from < 0)
        from += s;
    else if (from >= s)
        from = s - 1;
    if (from >= 0) {
        T *b = ptr;
        T *n = ptr + from + 1;
        while (n != b) {
            if (*--n == t)
                return n - b;
        }
    }
    return -1;
}

template <class T, int Prealloc>
inline bool QVarLengthArray<T, Prealloc>::contains(const T &t) const
{
    T *b = ptr;
    T *i = ptr + s;
    while (i != b) {
        if (*--i == t)
            return true;
    }
    return false;
}

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::append(const T *abuf, int increment)
{
    ((abuf) ? static_cast<void>(0) : qt_assert("abuf", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 339));
    if (increment <= 0)
        return;

    const int asize = s + increment;

    if (asize >= a)
        realloc(s, qMax(s*2, asize));

    if (QTypeInfo<T>::isComplex) {
        
        while (s < asize)
            new (ptr+(s++)) T(*abuf++);
    } else {
        memcpy(static_cast<void *>(&ptr[s]), static_cast<const void *>(abuf), increment * sizeof(T));
        s = asize;
    }
}

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::squeeze()
{ realloc(s, s); }

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
{
    ((aalloc >= asize) ? static_cast<void>(0) : qt_assert("aalloc >= asize", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 365));
    T *oldPtr = ptr;
    int osize = s;

    const int copySize = qMin(asize, osize);
    do { const bool valueOfExpression = copySize >= 0; ((valueOfExpression) ? static_cast<void>(0) : qt_assert_x("Q_ASSUME()", "Assumption in Q_ASSUME(\"" "copySize >= 0" "\") was not correct", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 370)); __assume(valueOfExpression); } while (false);
    if (aalloc != a) {
        if (aalloc > Prealloc) {
            T* newPtr = reinterpret_cast<T *>(malloc(aalloc * sizeof(T)));
            do { if (!(newPtr)) qBadAlloc(); } while (false); 
            
            ptr = newPtr;
            a = aalloc;
        } else {
            ptr = reinterpret_cast<T *>(array);
            a = Prealloc;
        }
        s = 0;
        if (!QTypeInfoQuery<T>::isRelocatable) {
            try {
                
                while (s < copySize) {
                    new (ptr+s) T(std::move(*(oldPtr+s)));
                    (oldPtr+s)->~T();
                    s++;
                }
            } catch (...) {
                
                int sClean = s;
                while (sClean < osize)
                    (oldPtr+(sClean++))->~T();
                if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
                    free(oldPtr);
                throw;
            }
        } else {
            memcpy(static_cast<void *>(ptr), static_cast<const void *>(oldPtr), copySize * sizeof(T));
        }
    }
    s = copySize;

    if (QTypeInfo<T>::isComplex) {
        
        while (osize > asize)
            (oldPtr+(--osize))->~T();
    }

    if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
        free(oldPtr);

    if (QTypeInfo<T>::isComplex) {
        
        while (s < asize)
            new (ptr+(s++)) T;
    } else {
        s = asize;
    }
}

template <class T, int Prealloc>
inline T QVarLengthArray<T, Prealloc>::value(int i) const
{
    if (uint(i) >= uint(size())) {
        return T();
    }
    return at(i);
}
template <class T, int Prealloc>
inline T QVarLengthArray<T, Prealloc>::value(int i, const T &defaultValue) const
{
    return (uint(i) >= uint(size())) ? defaultValue : at(i);
}

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::insert(int i, T &&t)
{ ((i >= 0 && i <= s) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 440));
  insert(cbegin() + i, std::move(t)); }
template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::insert(int i, const T &t)
{ ((i >= 0 && i <= s) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 444));
  insert(begin() + i, 1, t); }
template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::insert(int i, int n, const T &t)
{ ((i >= 0 && i <= s) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 448));
  insert(begin() + i, n, t); }
template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::remove(int i, int n)
{ ((i >= 0 && n >= 0 && i + n <= s) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::remove", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 452));
  erase(begin() + i, begin() + i + n); }
template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::remove(int i)
{ ((i >= 0 && i < s) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::remove", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 456));
  erase(begin() + i, begin() + i + 1); }
template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::prepend(T &&t)
{ insert(cbegin(), std::move(t)); }
template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::prepend(const T &t)
{ insert(begin(), 1, t); }

template <class T, int Prealloc>
inline void QVarLengthArray<T, Prealloc>::replace(int i, const T &t)
{
    ((i >= 0 && i < s) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::replace", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 468));
    const T copy(t);
    data()[i] = copy;
}

template <class T, int Prealloc>
inline typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::insert(const_iterator before, T &&t)
{
    ((isValidIterator(before)) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "The specified const_iterator argument 'before' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 476));

    int offset = int(before - ptr);
    reserve(s + 1);
    if (!QTypeInfo<T>::isRelocatable) {
        T *b = ptr + offset;
        T *i = ptr + s;
        T *j = i + 1;
        
        if (i != b) {
            new (--j) T(std::move(*--i));
            while (i != b)
                *--j = std::move(*--i);
            *b = std::move(t);
        } else {
            new (b) T(std::move(t));
        }
    } else {
        T *b = ptr + offset;
        memmove(static_cast<void *>(b + 1), static_cast<const void *>(b), (s - offset) * sizeof(T));
        new (b) T(std::move(t));
    }
    s += 1;
    return ptr + offset;
}

template <class T, int Prealloc>
inline typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::insert(const_iterator before, int n, const T &t)
{
    ((isValidIterator(before)) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "The specified const_iterator argument 'before' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 505));

    int offset = int(before - ptr);
    if (n != 0) {
        const T copy(t); 
        resize(s + n);
        if (!QTypeInfoQuery<T>::isRelocatable) {
            T *b = ptr + offset;
            T *j = ptr + s;
            T *i = j - n;
            while (i != b)
                *--j = *--i;
            i = b + n;
            while (i != b)
                *--i = copy;
        } else {
            T *b = ptr + offset;
            T *i = b + n;
            memmove(static_cast<void *>(i), static_cast<const void *>(b), (s - offset - n) * sizeof(T));
            while (i != b)
                new (--i) T(copy);
        }
    }
    return ptr + offset;
}

template <class T, int Prealloc>
inline typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::erase(const_iterator abegin, const_iterator aend)
{
    ((isValidIterator(abegin)) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "The specified const_iterator argument 'abegin' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 534));
    ((isValidIterator(aend)) ? static_cast<void>(0) : qt_assert_x("QVarLengthArray::insert", "The specified const_iterator argument 'aend' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 535));

    int f = int(abegin - ptr);
    int l = int(aend - ptr);
    int n = l - f;

    if (n == 0) 
        return data() + f;

    ((n > 0) ? static_cast<void>(0) : qt_assert("n > 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h", 544)); 

    if (QTypeInfo<T>::isComplex) {
        std::copy(ptr + l, ptr + s, stdext::make_checked_array_iterator(ptr + f, size_t(s - f)));
        T *i = ptr + s;
        T *b = ptr + s - n;
        while (i != b) {
            --i;
            i->~T();
        }
    } else {
        memmove(static_cast<void *>(ptr + f), static_cast<const void *>(ptr + l), (s - l) * sizeof(T));
    }
    s -= n;
    return ptr + f;
}

template <typename T, int Prealloc1, int Prealloc2>
bool operator==(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
{
    if (l.size() != r.size())
        return false;
    const T *rb = r.begin();
    const T *b  = l.begin();
    const T *e  = l.end();
    return std::equal(b, e, stdext::make_checked_array_iterator(rb, size_t(r.size())));
}

template <typename T, int Prealloc1, int Prealloc2>
bool operator!=(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
{
    return !(l == r);
}

template <typename T, int Prealloc1, int Prealloc2>
bool operator<(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
    noexcept(noexcept(std::lexicographical_compare(lhs.begin(), lhs.end(),
                                                               rhs.begin(), rhs.end())))
{
    return std::lexicographical_compare(lhs.begin(), lhs.end(),
                                        rhs.begin(), rhs.end());
}

template <typename T, int Prealloc1, int Prealloc2>
inline bool operator>(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return rhs < lhs;
}

template <typename T, int Prealloc1, int Prealloc2>
inline bool operator<=(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return !(lhs > rhs);
}

template <typename T, int Prealloc1, int Prealloc2>
inline bool operator>=(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
    noexcept(noexcept(lhs < rhs))
{
    return !(lhs < rhs);
}

template <typename T, int Prealloc>
uint qHash(const QVarLengthArray<T, Prealloc> &key, uint seed = 0)
    noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
{
    return qHashRange(key.cbegin(), key.cend(), seed);
}



#line 618 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvarlengtharray.h"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"


#line 52 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"













enum class QCborSimpleType : quint8;

template <typename T>
struct QMetaTypeId2;

template <typename T>
inline constexpr int qMetaTypeId();






























#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"







#line 111 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
































































































































class QDataStream;
class QMetaTypeInterface;
struct QMetaObject;

namespace QtPrivate
{




template<typename From, typename To>
To convertImplicit(const From& from)
{
    return from;
}


struct AbstractDebugStreamFunction
{
    typedef void (*Stream)(const AbstractDebugStreamFunction *, QDebug&, const void *);
    typedef void (*Destroy)(AbstractDebugStreamFunction *);
    explicit AbstractDebugStreamFunction(Stream s = nullptr, Destroy d = nullptr)
        : stream(s), destroy(d) {}
    AbstractDebugStreamFunction(const AbstractDebugStreamFunction &) = delete; AbstractDebugStreamFunction &operator=(const AbstractDebugStreamFunction &) = delete;
    Stream stream;
    Destroy destroy;
};

template<typename T>
struct BuiltInDebugStreamFunction : public AbstractDebugStreamFunction
{
    BuiltInDebugStreamFunction()
        : AbstractDebugStreamFunction(stream, destroy) {}
    static void stream(const AbstractDebugStreamFunction *, QDebug& dbg, const void *r)
    {
        const T *rhs = static_cast<const T *>(r);
        operator<<(dbg, *rhs);
    }

    static void destroy(AbstractDebugStreamFunction *_this)
    {
        delete static_cast<BuiltInDebugStreamFunction *>(_this);
    }
};
#line 284 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

struct AbstractComparatorFunction
{
    typedef bool (*LessThan)(const AbstractComparatorFunction *, const void *, const void *);
    typedef bool (*Equals)(const AbstractComparatorFunction *, const void *, const void *);
    typedef void (*Destroy)(AbstractComparatorFunction *);
    explicit AbstractComparatorFunction(LessThan lt = nullptr, Equals e = nullptr, Destroy d = nullptr)
        : lessThan(lt), equals(e), destroy(d) {}
    AbstractComparatorFunction(const AbstractComparatorFunction &) = delete; AbstractComparatorFunction &operator=(const AbstractComparatorFunction &) = delete;
    LessThan lessThan;
    Equals equals;
    Destroy destroy;
};

template<typename T>
struct BuiltInComparatorFunction : public AbstractComparatorFunction
{
    BuiltInComparatorFunction()
        : AbstractComparatorFunction(lessThan, equals, destroy) {}
    static bool lessThan(const AbstractComparatorFunction *, const void *l, const void *r)
    {
        const T *lhs = static_cast<const T *>(l);
        const T *rhs = static_cast<const T *>(r);
        return *lhs < *rhs;
    }

    static bool equals(const AbstractComparatorFunction *, const void *l, const void *r)
    {
        const T *lhs = static_cast<const T *>(l);
        const T *rhs = static_cast<const T *>(r);
        return *lhs == *rhs;
    }

    static void destroy(AbstractComparatorFunction *_this)
    {
        delete static_cast<BuiltInComparatorFunction *>(_this);
    }
};

template<typename T>
struct BuiltInEqualsComparatorFunction : public AbstractComparatorFunction
{
    BuiltInEqualsComparatorFunction()
        : AbstractComparatorFunction(nullptr, equals, destroy) {}
    static bool equals(const AbstractComparatorFunction *, const void *l, const void *r)
    {
        const T *lhs = static_cast<const T *>(l);
        const T *rhs = static_cast<const T *>(r);
        return *lhs == *rhs;
    }

    static void destroy(AbstractComparatorFunction *_this)
    {
        delete static_cast<BuiltInEqualsComparatorFunction *>(_this);
    }
};

struct AbstractConverterFunction
{
    typedef bool (*Converter)(const AbstractConverterFunction *, const void *, void*);
    explicit AbstractConverterFunction(Converter c = nullptr)
        : convert(c) {}
    AbstractConverterFunction(const AbstractConverterFunction &) = delete; AbstractConverterFunction &operator=(const AbstractConverterFunction &) = delete;
    Converter convert;
};

template<typename From, typename To>
struct ConverterMemberFunction : public AbstractConverterFunction
{
    explicit ConverterMemberFunction(To(From::*function)() const)
        : AbstractConverterFunction(convert),
          m_function(function) {}
    ~ConverterMemberFunction();
    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
    {
        const From *f = static_cast<const From *>(in);
        To *t = static_cast<To *>(out);
        const ConverterMemberFunction *_typedThis =
            static_cast<const ConverterMemberFunction *>(_this);
        *t = (f->*_typedThis->m_function)();
        return true;
    }

    To(From::* const m_function)() const;
};

template<typename From, typename To>
struct ConverterMemberFunctionOk : public AbstractConverterFunction
{
    explicit ConverterMemberFunctionOk(To(From::*function)(bool *) const)
        : AbstractConverterFunction(convert),
          m_function(function) {}
    ~ConverterMemberFunctionOk();
    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
    {
        const From *f = static_cast<const From *>(in);
        To *t = static_cast<To *>(out);
        bool ok = false;
        const ConverterMemberFunctionOk *_typedThis =
            static_cast<const ConverterMemberFunctionOk *>(_this);
        *t = (f->*_typedThis->m_function)(&ok);
        if (!ok)
            *t = To();
        return ok;
    }

    To(From::* const m_function)(bool*) const;
};

template<typename From, typename To, typename UnaryFunction>
struct ConverterFunctor : public AbstractConverterFunction
{
    explicit ConverterFunctor(UnaryFunction function)
        : AbstractConverterFunction(convert),
          m_function(function) {}
    ~ConverterFunctor();
    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
    {
        const From *f = static_cast<const From *>(in);
        To *t = static_cast<To *>(out);
        const ConverterFunctor *_typedThis =
            static_cast<const ConverterFunctor *>(_this);
        *t = _typedThis->m_function(*f);
        return true;
    }

    UnaryFunction m_function;
};

    template<typename T, bool>
    struct ValueTypeIsMetaType;
    template<typename T, bool>
    struct AssociativeValueTypeIsMetaType;
    template<typename T, bool>
    struct IsMetaTypePair;
    template<typename, typename>
    struct MetaTypeSmartPointerHelper;
}

class __declspec(dllimport) QMetaType {
    enum ExtensionFlag { NoExtensionFlags,
                         CreateEx = 0x1, DestroyEx = 0x2,
                         ConstructEx = 0x4, DestructEx = 0x8,
                         NameEx = 0x10, SizeEx = 0x20,
                         CtorEx = 0x40, DtorEx = 0x80,
                         FlagsEx = 0x100, MetaObjectEx = 0x200
                       };
public:

    
    enum Type {
        
        Void = 43, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5, Double = 6, Long = 32, Short = 33, Char = 34, ULong = 35, UShort = 36, UChar = 37, Float = 38, SChar = 40, Nullptr = 51, QCborSimpleType = 52, VoidStar = 31, QChar = 7, QString = 10, QStringList = 11, QByteArray = 12, QBitArray = 13, QDate = 14, QTime = 15, QDateTime = 16, QUrl = 17, QLocale = 18, QRect = 19, QRectF = 20, QSize = 21, QSizeF = 22, QLine = 23, QLineF = 24, QPoint = 25, QPointF = 26, QRegExp = 27, QEasingCurve = 29, QUuid = 30, QVariant = 41, QRegularExpression = 44, QJsonValue = 45, QJsonObject = 46, QJsonArray = 47, QJsonDocument = 48, QCborValue = 53, QCborArray = 54, QCborMap = 55, QModelIndex = 42, QPersistentModelIndex = 50, QObjectStar = 39, QVariantMap = 8, QVariantList = 9, QVariantHash = 28, QByteArrayList = 49, QFont = 64, QPixmap = 65, QBrush = 66, QColor = 67, QPalette = 68, QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73, QCursor = 74, QKeySequence = 75, QPen = 76, QTextLength = 77, QTextFormat = 78, QMatrix = 79, QTransform = 80, QMatrix4x4 = 81, QVector2D = 82, QVector3D = 83, QVector4D = 84, QQuaternion = 85, QPolygonF = 86, QColorSpace = 87, QSizePolicy = 121,

        FirstCoreType = Bool,
        LastCoreType = QCborMap,
        FirstGuiType = QFont,
        LastGuiType = QColorSpace,
        FirstWidgetsType = QSizePolicy,
        LastWidgetsType = QSizePolicy,
        HighestInternalId = LastWidgetsType,

        QReal = sizeof(qreal) == sizeof(double) ? Double : Float,

        UnknownType = 0,
        User = 1024
    };

































#line 485 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

    enum TypeFlag {
        NeedsConstruction = 0x1,
        NeedsDestruction = 0x2,
        MovableType = 0x4,
        PointerToQObject = 0x8,
        IsEnumeration = 0x10,
        SharedPointerToQObject = 0x20,
        WeakPointerToQObject = 0x40,
        TrackingPointerToQObject = 0x80,
        WasDeclaredAsMetaType = 0x100,
        IsGadget = 0x200,
        PointerToGadget = 0x400
    };
    typedef QFlags<TypeFlag> TypeFlags;

    typedef void (*Deleter)(void *);
    typedef void *(*Creator)(const void *);


    typedef void (*Destructor)(void *);
    typedef void *(*Constructor)(void *, const void *); 
#line 508 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
    typedef void (*TypedDestructor)(int, void *);
    typedef void *(*TypedConstructor)(int, void *, const void *);

    typedef void (*SaveOperator)(QDataStream &, const void *);
    typedef void (*LoadOperator)(QDataStream &, void *);

    static void registerStreamOperators(const char *typeName, SaveOperator saveOp,
                                        LoadOperator loadOp);
    static void registerStreamOperators(int type, SaveOperator saveOp,
                                        LoadOperator loadOp);
#line 519 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
    static int registerType(const char *typeName, Deleter deleter,
                            Creator creator);
    static int registerType(const char *typeName, Deleter deleter,
                            Creator creator,
                            Destructor destructor,
                            Constructor constructor,
                            int size,
                            QMetaType::TypeFlags flags,
                            const QMetaObject *metaObject);
    static int registerType(const char *typeName,
                            TypedDestructor destructor,
                            TypedConstructor constructor,
                            int size,
                            QMetaType::TypeFlags flags,
                            const QMetaObject *metaObject);
    static bool unregisterType(int type);
    static int registerNormalizedType(const ::QByteArray &normalizedTypeName, Deleter deleter,
                            Creator creator,
                            Destructor destructor,
                            Constructor constructor,
                            int size,
                            QMetaType::TypeFlags flags,
                            const QMetaObject *metaObject);
    static int registerNormalizedType(const ::QByteArray &normalizedTypeName, Destructor destructor,
                            Constructor constructor,
                            int size,
                            QMetaType::TypeFlags flags,
                            const QMetaObject *metaObject);
    static int registerNormalizedType(const ::QByteArray &normalizedTypeName, TypedDestructor destructor,
                            TypedConstructor constructor,
                            int size,
                            QMetaType::TypeFlags flags,
                            const QMetaObject *metaObject);
    static int registerTypedef(const char *typeName, int aliasId);
    static int registerNormalizedTypedef(const ::QByteArray &normalizedTypeName, int aliasId);
    static int type(const char *typeName);

    static int type(const ::QByteArray &typeName);
    static const char *typeName(int type);
    static int sizeOf(int type);
    static TypeFlags typeFlags(int type);
    static const QMetaObject *metaObjectForType(int type);
    static bool isRegistered(int type);
    static void *create(int type, const void *copy = nullptr);



#line 567 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
    static void destroy(int type, void *data);
    static void *construct(int type, void *where, const void *copy);
    static void destruct(int type, void *where);


    static bool save(QDataStream &stream, int type, const void *data);
    static bool load(QDataStream &stream, int type, void *data);
#line 575 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

    explicit QMetaType(const int type = QMetaType::UnknownType); 
    inline ~QMetaType();

    inline bool isValid() const;
    inline bool isRegistered() const;
    inline int id() const;
    inline int sizeOf() const;
    inline TypeFlags flags() const;
    inline const QMetaObject *metaObject() const;
    ::QByteArray name() const;

    inline void *create(const void *copy = nullptr) const;
    inline void destroy(void *data) const;
    inline void *construct(void *where, const void *copy = nullptr) const;
    inline void destruct(void *data) const;

    template<typename T>
    static QMetaType fromType()
    { return QMetaType(qMetaTypeId<T>()); }

    friend bool operator==(const QMetaType &a, const QMetaType &b)
    { return a.m_typeId == b.m_typeId; }

    friend bool operator!=(const QMetaType &a, const QMetaType &b)
    { return a.m_typeId != b.m_typeId; }


public:
    template<typename T>
    static bool registerComparators()
    {
        static_assert(bool((!QMetaTypeId2<T>::IsBuiltIn)), "QMetaType::registerComparators: The type must be a custom type.");
#line 609 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

        const int typeId = qMetaTypeId<T>();
        static const QtPrivate::BuiltInComparatorFunction<T> f;
        return registerComparatorFunction( &f, typeId);
    }
    template<typename T>
    static bool registerEqualsComparator()
    {
        static_assert(bool((!QMetaTypeId2<T>::IsBuiltIn)), "QMetaType::registerEqualsComparator: The type must be a custom type.");
#line 619 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
        const int typeId = qMetaTypeId<T>();
        static const QtPrivate::BuiltInEqualsComparatorFunction<T> f;
        return registerComparatorFunction( &f, typeId);
    }

    template<typename T>
    static bool hasRegisteredComparators()
    {
        return hasRegisteredComparators(qMetaTypeId<T>());
    }
    static bool hasRegisteredComparators(int typeId);



    template<typename T>
    static bool registerDebugStreamOperator()
    {
        static_assert(bool((!QMetaTypeId2<T>::IsBuiltIn)), "QMetaType::registerDebugStreamOperator: The type must be a custom type.");
#line 638 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

        const int typeId = qMetaTypeId<T>();
        static const QtPrivate::BuiltInDebugStreamFunction<T> f;
        return registerDebugStreamOperatorFunction(&f, typeId);
    }
    template<typename T>
    static bool hasRegisteredDebugStreamOperator()
    {
        return hasRegisteredDebugStreamOperator(qMetaTypeId<T>());
    }
    static bool hasRegisteredDebugStreamOperator(int typeId);
#line 650 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

    
    template<typename From, typename To>
    static bool registerConverter()
    {
        return registerConverter<From, To>(QtPrivate::convertImplicit<From, To>);
    }









    
    template<typename From, typename To>
    static bool registerConverter(To(From::*function)() const)
    {
        static_assert(bool((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn)), "QMetaType::registerConverter: At least one of the types must be a custom type.");
#line 672 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

        const int fromTypeId = qMetaTypeId<From>();
        const int toTypeId = qMetaTypeId<To>();
        static const QtPrivate::ConverterMemberFunction<From, To> f(function);
        return registerConverterFunction(&f, fromTypeId, toTypeId);
    }

    
    template<typename From, typename To>
    static bool registerConverter(To(From::*function)(bool*) const)
    {
        static_assert(bool((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn)), "QMetaType::registerConverter: At least one of the types must be a custom type.");
#line 685 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

        const int fromTypeId = qMetaTypeId<From>();
        const int toTypeId = qMetaTypeId<To>();
        static const QtPrivate::ConverterMemberFunctionOk<From, To> f(function);
        return registerConverterFunction(&f, fromTypeId, toTypeId);
    }

    
    template<typename From, typename To, typename UnaryFunction>
    static bool registerConverter(UnaryFunction function)
    {
        static_assert(bool((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn)), "QMetaType::registerConverter: At least one of the types must be a custom type.");
#line 698 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

        const int fromTypeId = qMetaTypeId<From>();
        const int toTypeId = qMetaTypeId<To>();
        static const QtPrivate::ConverterFunctor<From, To, UnaryFunction> f(function);
        return registerConverterFunction(&f, fromTypeId, toTypeId);
    }
#line 705 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

    static bool convert(const void *from, int fromTypeId, void *to, int toTypeId);
    static bool compare(const void *lhs, const void *rhs, int typeId, int* result);
    static bool equals(const void *lhs, const void *rhs, int typeId, int* result);
    static bool debugStream(QDebug& dbg, const void *rhs, int typeId);

    template<typename From, typename To>
    static bool hasRegisteredConverterFunction()
    {
        return hasRegisteredConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
    }

    static bool hasRegisteredConverterFunction(int fromTypeId, int toTypeId);

private:
    static QMetaType typeInfo(const int type);
    inline QMetaType(const ExtensionFlag extensionFlags, const QMetaTypeInterface *info,
                     TypedConstructor creator,
                     TypedDestructor deleter,
                     SaveOperator saveOp,
                     LoadOperator loadOp,
                     Constructor constructor,
                     Destructor destructor,
                     uint sizeOf,
                     uint theTypeFlags,
                     int typeId,
                     const QMetaObject *metaObject);
    QMetaType(const QMetaType &other);
    QMetaType &operator =(const QMetaType &);
    inline bool isExtended(const ExtensionFlag flag) const { return m_extensionFlags & flag; }

    
    void ctor(const QMetaTypeInterface *info);
    void dtor();
    uint sizeExtended() const;
    QMetaType::TypeFlags flagsExtended() const;
    const QMetaObject *metaObjectExtended() const;
    void *createExtended(const void *copy = nullptr) const;
    void destroyExtended(void *data) const;
    void *constructExtended(void *where, const void *copy = nullptr) const;
    void destructExtended(void *data) const;

    static bool registerComparatorFunction(const QtPrivate::AbstractComparatorFunction *f, int type);

    static bool registerDebugStreamOperatorFunction(const QtPrivate::AbstractDebugStreamFunction *f, int type);
#line 751 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"












#line 764 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
public:
#line 766 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
    static bool registerConverterFunction(const QtPrivate::AbstractConverterFunction *f, int from, int to);
    static void unregisterConverterFunction(int from, int to);
private:

    TypedConstructor m_typedConstructor;
    TypedDestructor m_typedDestructor;
    SaveOperator m_saveOp;
    LoadOperator m_loadOp;
    Constructor m_constructor;
    Destructor m_destructor;
    void *m_extension; 
    uint m_size;
    uint m_typeFlags;
    uint m_extensionFlags;
    int m_typeId;
    const QMetaObject *m_metaObject;
};



constexpr inline QFlags<QMetaType::TypeFlags::enum_type> operator|(QMetaType::TypeFlags::enum_type f1, QMetaType::TypeFlags::enum_type f2) noexcept { return QFlags<QMetaType::TypeFlags::enum_type>(f1) | f2; } constexpr inline QFlags<QMetaType::TypeFlags::enum_type> operator|(QMetaType::TypeFlags::enum_type f1, QFlags<QMetaType::TypeFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QMetaType::TypeFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

namespace QtPrivate {

template<typename From, typename To>
ConverterMemberFunction<From, To>::~ConverterMemberFunction()
{
    QMetaType::unregisterConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
}
template<typename From, typename To>
ConverterMemberFunctionOk<From, To>::~ConverterMemberFunctionOk()
{
    QMetaType::unregisterConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
}
template<typename From, typename To, typename UnaryFunction>
ConverterFunctor<From, To, UnaryFunction>::~ConverterFunctor()
{
    QMetaType::unregisterConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
}

}






namespace QtMetaTypePrivate {
template <typename T, bool Accepted = true>
struct QMetaTypeFunctionHelper {
    static void Destruct(void *t)
    {
        (void)t; 
        static_cast<T*>(t)->~T();
    }

    static void *Construct(void *where, const void *t)
    {
        if (t)
            return new (where) T(*static_cast<const T*>(t));
        return new (where) T;
    }

    static void Save(QDataStream &stream, const void *t)
    {
        stream << *static_cast<const T*>(t);
    }

    static void Load(QDataStream &stream, void *t)
    {
        stream >> *static_cast<T*>(t);
    }
#line 839 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
};

template <typename T>
struct QMetaTypeFunctionHelper<T,  false> {
    static void Destruct(void *) {}
    static void *Construct(void *, const void *) { return nullptr; }

    static void Save(QDataStream &, const void *) {}
    static void Load(QDataStream &, void *) {}
#line 849 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
};
template <>
struct QMetaTypeFunctionHelper<void,  true>
        : public QMetaTypeFunctionHelper<void,  false>
{};

struct VariantData
{
    VariantData(const int metaTypeId_,
                const void *data_,
                const uint flags_)
      : metaTypeId(metaTypeId_)
      , data(data_)
      , flags(flags_)
    {
    }
    VariantData(const VariantData &other)
        : metaTypeId(other.metaTypeId), data(other.data), flags(other.flags){}
    const int metaTypeId;
    const void *data;
    const uint flags;
private:
    
    VariantData &operator=(const VariantData &) = delete;
};

template<typename const_iterator>
struct IteratorOwnerCommon
{
    static void assign(void **ptr, const_iterator iterator)
    {
        *ptr = new const_iterator(iterator);
    }
    static void assign(void **ptr, void * const * src)
    {
        *ptr = new const_iterator(*static_cast<const_iterator*>(*src));
    }

    static void advance(void **iterator, int step)
    {
        const_iterator &it = *static_cast<const_iterator*>(*iterator);
        std::advance(it, step);
    }

    static void destroy(void **ptr)
    {
        delete static_cast<const_iterator*>(*ptr);
    }

    static bool equal(void * const *it, void * const *other)
    {
        return *static_cast<const_iterator*>(*it) == *static_cast<const_iterator*>(*other);
    }
};

template<typename const_iterator>
struct IteratorOwner : IteratorOwnerCommon<const_iterator>
{
    static const void *getData(void * const *iterator)
    {
        return &**static_cast<const_iterator*>(*iterator);
    }

    static const void *getData(const_iterator it)
    {
        return &*it;
    }
};

struct __declspec(dllimport) VectorBoolElements
{
  static const bool true_element;
  static const bool false_element;
};

template<>
struct IteratorOwner<std::vector<bool>::const_iterator> : IteratorOwnerCommon<std::vector<bool>::const_iterator>
{
public:
    static const void *getData(void * const *iterator)
    {
        return **static_cast<std::vector<bool>::const_iterator*>(*iterator) ?
            &VectorBoolElements::true_element : &VectorBoolElements::false_element;
    }

    static const void *getData(const std::vector<bool>::const_iterator& it)
    {
        return *it ? &VectorBoolElements::true_element : &VectorBoolElements::false_element;
    }
};

template<typename value_type>
struct IteratorOwner<const value_type*>
{
private:
    
    
    
    struct Dummy {};
    typedef typename std::conditional<std::is_same<value_type, void*>::value, Dummy, value_type>::type value_type_OR_Dummy;
public:
    static void assign(void **ptr, const value_type_OR_Dummy *iterator )
    {
        *ptr = const_cast<value_type*>(iterator);
    }
    static void assign(void **ptr, void * const * src)
    {
        *ptr = static_cast<value_type*>(*src);
    }

    static void advance(void **iterator, int step)
    {
        value_type *it = static_cast<value_type*>(*iterator);
        std::advance(it, step);
        *iterator = it;
    }

    static void destroy(void **)
    {
    }

    static const void *getData(void * const *iterator)
    {
        return *iterator;
    }

    static const void *getData(const value_type_OR_Dummy *it)
    {
        return it;
    }

    static bool equal(void * const *it, void * const *other)
    {
        return static_cast<value_type*>(*it) == static_cast<value_type*>(*other);
    }
};

enum IteratorCapability
{
    ForwardCapability = 1,
    BiDirectionalCapability = 2,
    RandomAccessCapability = 4
};

enum ContainerCapability
{
    ContainerIsAppendable = 1
};

template<typename Container, typename T = void>
struct ContainerCapabilitiesImpl
{
    enum {ContainerCapabilities = 0};
    using appendFunction = void(*)(const void *container, const void *newElement);
    static constexpr const appendFunction appendImpl = nullptr;
};

template<typename Container>
struct ContainerCapabilitiesImpl<Container, decltype(std::declval<Container>().push_back(std::declval<typename Container::value_type>()))>
{
    enum {ContainerCapabilities = ContainerIsAppendable};

    
    
    static void appendImpl(const void *container, const void *value)
    { static_cast<Container *>(const_cast<void *>(container))->push_back(*static_cast<const typename Container::value_type *>(value)); }
};

namespace QtPrivate {
namespace ContainerCapabilitiesMetaProgrammingHelper {
    template<typename... Ts>
    using void_t = void;
}
}

template<typename Container>
struct ContainerCapabilitiesImpl<Container, QtPrivate::ContainerCapabilitiesMetaProgrammingHelper::void_t<decltype(std::declval<Container>().insert(std::declval<typename Container::value_type>())), decltype(std::declval<typename Container::value_type>() == std::declval<typename Container::value_type>())>>
{
    enum {ContainerCapabilities = ContainerIsAppendable};

    
    
    static void appendImpl(const void *container, const void *value)
    { static_cast<Container *>(const_cast<void *>(container))->insert(*static_cast<const typename Container::value_type *>(value)); }
};

template<typename T, typename Category = typename std::iterator_traits<typename T::const_iterator>::iterator_category>
struct CapabilitiesImpl;

template<typename T>
struct CapabilitiesImpl<T, std::forward_iterator_tag>
{ enum { IteratorCapabilities = ForwardCapability }; };
template<typename T>
struct CapabilitiesImpl<T, std::bidirectional_iterator_tag>
{ enum { IteratorCapabilities = BiDirectionalCapability | ForwardCapability }; };
template<typename T>
struct CapabilitiesImpl<T, std::random_access_iterator_tag>
{ enum { IteratorCapabilities = RandomAccessCapability | BiDirectionalCapability | ForwardCapability }; };

template<typename T>
struct ContainerAPI : CapabilitiesImpl<T>
{
    static int size(const T *t) { return int(std::distance(t->begin(), t->end())); }
};

template<typename T>
struct ContainerAPI<QList<T> > : CapabilitiesImpl<QList<T> >
{ static int size(const QList<T> *t) { return t->size(); } };

template<typename T>
struct ContainerAPI<QVector<T> > : CapabilitiesImpl<QVector<T> >
{ static int size(const QVector<T> *t) { return t->size(); } };

template<typename T>
struct ContainerAPI<std::vector<T> > : CapabilitiesImpl<std::vector<T> >
{ static int size(const std::vector<T> *t) { return int(t->size()); } };

template<typename T>
struct ContainerAPI<std::list<T> > : CapabilitiesImpl<std::list<T> >
{ static int size(const std::list<T> *t) { return int(t->size()); } };







class QSequentialIterableImpl
{
public:
    const void * _iterable;
    void *_iterator;
    int _metaType_id;
    uint _metaType_flags;
    uint _iteratorCapabilities;
    
    
    
    
    
    typedef int(*sizeFunc)(const void *p);
    typedef const void * (*atFunc)(const void *p, int);
    typedef void (*moveIteratorFunc)(const void *p, void **);
    enum Position { ToBegin, ToEnd };
    typedef void (*moveIteratorFunc2)(const void *p, void **, Position position);
    typedef void (*advanceFunc)(void **p, int);
    typedef VariantData (*getFunc)( void * const *p, int metaTypeId, uint flags);
    typedef void (*destroyIterFunc)(void **p);
    typedef bool (*equalIterFunc)(void * const *p, void * const *other);
    typedef void (*copyIterFunc)(void **, void * const *);
    typedef void(*appendFunction)(const void *container, const void *newElement);

    IteratorCapability iteratorCapabilities() {return static_cast<IteratorCapability>(_iteratorCapabilities & 0xF);}
    uint revision() {return _iteratorCapabilities >> 4 & 0x7;}
    uint containerCapabilities() {return _iteratorCapabilities >> 7 & 0xF;}

    sizeFunc _size;
    atFunc _at;
    union {
        moveIteratorFunc _moveToBegin;
        moveIteratorFunc2 _moveTo;
    };
    union {
        moveIteratorFunc _moveToEnd;
        appendFunction _append;
    };
    advanceFunc _advance;
    getFunc _get;
    destroyIterFunc _destroyIter;
    equalIterFunc _equalIter;
    copyIterFunc _copyIter;

    template<class T>
    static int sizeImpl(const void *p)
    { return ContainerAPI<T>::size(static_cast<const T*>(p)); }

    template<class T>
    static const void* atImpl(const void *p, int idx)
    {
        typename T::const_iterator i = static_cast<const T*>(p)->begin();
        std::advance(i, idx);
        return IteratorOwner<typename T::const_iterator>::getData(i);
    }

    template<class T>
    static void moveToBeginImpl(const void *container, void **iterator)
    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->begin()); }

    template<class T>
    static void moveToEndImpl(const void *container, void **iterator)
    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->end()); }

    template<class Container>
    static void moveToImpl(const void *container, void **iterator, Position position)
    {
        if (position == ToBegin)
            moveToBeginImpl<Container>(container, iterator);
        else
            moveToEndImpl<Container>(container, iterator);
    }

    template<class T>
    static VariantData getImpl(void * const *iterator, int metaTypeId, uint flags)
    { return VariantData(metaTypeId, IteratorOwner<typename T::const_iterator>::getData(iterator), flags); }

public:
    template<class T> QSequentialIterableImpl(const T*p)
      : _iterable(p)
      , _iterator(nullptr)
      , _metaType_id(qMetaTypeId<typename T::value_type>())
      , _metaType_flags(QTypeInfo<typename T::value_type>::isPointer)
      , _iteratorCapabilities(ContainerAPI<T>::IteratorCapabilities | (1 << 4) | (ContainerCapabilitiesImpl<T>::ContainerCapabilities << (4+3)))
      , _size(sizeImpl<T>)
      , _at(atImpl<T>)
      , _moveTo(moveToImpl<T>)
      , _append(ContainerCapabilitiesImpl<T>::appendImpl)
      , _advance(IteratorOwner<typename T::const_iterator>::advance)
      , _get(getImpl<T>)
      , _destroyIter(IteratorOwner<typename T::const_iterator>::destroy)
      , _equalIter(IteratorOwner<typename T::const_iterator>::equal)
      , _copyIter(IteratorOwner<typename T::const_iterator>::assign)
    {
    }

    QSequentialIterableImpl()
      : _iterable(nullptr)
      , _iterator(nullptr)
      , _metaType_id(QMetaType::UnknownType)
      , _metaType_flags(0)
      , _iteratorCapabilities(0 | (1 << 4) ) 
      , _size(nullptr)
      , _at(nullptr)
      , _moveToBegin(nullptr)
      , _moveToEnd(nullptr)
      , _advance(nullptr)
      , _get(nullptr)
      , _destroyIter(nullptr)
      , _equalIter(nullptr)
      , _copyIter(nullptr)
    {
    }

    inline void moveToBegin() {
        if (revision() == 0)
            _moveToBegin(_iterable, &_iterator);
        else
            _moveTo(_iterable, &_iterator, ToBegin);
    }
    inline void moveToEnd() {
        if (revision() == 0)
            _moveToEnd(_iterable, &_iterator);
        else
            _moveTo(_iterable, &_iterator, ToEnd);
    }
    inline bool equal(const QSequentialIterableImpl&other) const { return _equalIter(&_iterator, &other._iterator); }
    inline QSequentialIterableImpl &advance(int i) {
      ((i > 0 || _iteratorCapabilities & BiDirectionalCapability) ? static_cast<void>(0) : qt_assert("i > 0 || _iteratorCapabilities & BiDirectionalCapability", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 1205));
      _advance(&_iterator, i);
      return *this;
    }

    inline void append(const void *newElement) {
        if (containerCapabilities() & ContainerIsAppendable)
            _append(_iterable, newElement);
    }

    inline VariantData getCurrent() const { return _get(&_iterator, _metaType_id, _metaType_flags); }

    VariantData at(int idx) const
    { return VariantData(_metaType_id, _at(_iterable, idx), _metaType_flags); }

    int size() const { ((_iterable) ? static_cast<void>(0) : qt_assert("_iterable", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 1220)); return _size(_iterable); }

    inline void destroyIter() { _destroyIter(&_iterator); }

    void copy(const QSequentialIterableImpl &other)
    {
      *this = other;
      _copyIter(&_iterator, &other._iterator);
    }
};
} template<> class QTypeInfo<QtMetaTypePrivate:: QSequentialIterableImpl > { public: enum { isSpecialized = true, isComplex = ((((Q_MOVABLE_TYPE)) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QtMetaTypePrivate:: QSequentialIterableImpl>(), isStatic = ((((Q_MOVABLE_TYPE)) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || (((Q_MOVABLE_TYPE)) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QtMetaTypePrivate:: QSequentialIterableImpl>(), isLarge = (sizeof(QtMetaTypePrivate:: QSequentialIterableImpl)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QtMetaTypePrivate:: QSequentialIterableImpl >::value, isDummy = ((((Q_MOVABLE_TYPE)) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QtMetaTypePrivate:: QSequentialIterableImpl) }; static inline const char *name() { return "QtMetaTypePrivate:: QSequentialIterableImpl"; } }; namespace QtMetaTypePrivate {

template<typename From>
struct QSequentialIterableConvertFunctor
{
    QSequentialIterableImpl operator()(const From &f) const
    {
        return QSequentialIterableImpl(&f);
    }
};
}

namespace QtMetaTypePrivate {
template<typename T, bool = std::is_same<typename T::const_iterator::value_type, typename T::mapped_type>::value>
struct AssociativeContainerAccessor
{
    static const typename T::key_type& getKey(const typename T::const_iterator &it)
    {
        return it.key();
    }

    static const typename T::mapped_type& getValue(const typename T::const_iterator &it)
    {
        return it.value();
    }
};

template<typename T, bool = std::is_same<typename T::const_iterator::value_type, std::pair<const typename T::key_type, typename T::mapped_type> >::value>
struct StlStyleAssociativeContainerAccessor;

template<typename T>
struct StlStyleAssociativeContainerAccessor<T, true>
{
    static const typename T::key_type& getKey(const typename T::const_iterator &it)
    {
        return it->first;
    }

    static const typename T::mapped_type& getValue(const typename T::const_iterator &it)
    {
        return it->second;
    }
};

template<typename T>
struct AssociativeContainerAccessor<T, false> : public StlStyleAssociativeContainerAccessor<T>
{
};

class QAssociativeIterableImpl
{
public:
    const void *_iterable;
    void *_iterator;
    int _metaType_id_key;
    uint _metaType_flags_key;
    int _metaType_id_value;
    uint _metaType_flags_value;
    typedef int(*sizeFunc)(const void *p);
    typedef void (*findFunc)(const void *container, const void *p, void **iterator);
    typedef void (*beginFunc)(const void *p, void **);
    typedef void (*advanceFunc)(void **p, int);
    typedef VariantData (*getFunc)(void * const *p, int metaTypeId, uint flags);
    typedef void (*destroyIterFunc)(void **p);
    typedef bool (*equalIterFunc)(void * const *p, void * const *other);
    typedef void (*copyIterFunc)(void **, void * const *);

    sizeFunc _size;
    findFunc _find;
    beginFunc _begin;
    beginFunc _end;
    advanceFunc _advance;
    getFunc _getKey;
    getFunc _getValue;
    destroyIterFunc _destroyIter;
    equalIterFunc _equalIter;
    copyIterFunc _copyIter;

    template<class T>
    static int sizeImpl(const void *p)
    { return int(std::distance(static_cast<const T*>(p)->begin(),
                               static_cast<const T*>(p)->end())); }

    template<class T>
    static void findImpl(const void *container, const void *p, void **iterator)
    { IteratorOwner<typename T::const_iterator>::assign(iterator,
                                                        static_cast<const T*>(container)->find(*static_cast<const typename T::key_type*>(p))); }

    __pragma(warning(push))
    __pragma(warning(disable: 4996)) 
    template<class T>
    static void advanceImpl(void **p, int step)
    { std::advance(*static_cast<typename T::const_iterator*>(*p), step); }
    __pragma(warning(pop))

    template<class T>
    static void beginImpl(const void *container, void **iterator)
    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->begin()); }

    template<class T>
    static void endImpl(const void *container, void **iterator)
    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->end()); }

    template<class T>
    static VariantData getKeyImpl(void * const *iterator, int metaTypeId, uint flags)
    { return VariantData(metaTypeId, &AssociativeContainerAccessor<T>::getKey(*static_cast<typename T::const_iterator*>(*iterator)), flags); }

    template<class T>
    static VariantData getValueImpl(void * const *iterator, int metaTypeId, uint flags)
    { return VariantData(metaTypeId, &AssociativeContainerAccessor<T>::getValue(*static_cast<typename T::const_iterator*>(*iterator)), flags); }

public:
    template<class T> QAssociativeIterableImpl(const T*p)
      : _iterable(p)
      , _iterator(nullptr)
      , _metaType_id_key(qMetaTypeId<typename T::key_type>())
      , _metaType_flags_key(QTypeInfo<typename T::key_type>::isPointer)
      , _metaType_id_value(qMetaTypeId<typename T::mapped_type>())
      , _metaType_flags_value(QTypeInfo<typename T::mapped_type>::isPointer)
      , _size(sizeImpl<T>)
      , _find(findImpl<T>)
      , _begin(beginImpl<T>)
      , _end(endImpl<T>)
      , _advance(advanceImpl<T>)
      , _getKey(getKeyImpl<T>)
      , _getValue(getValueImpl<T>)
      , _destroyIter(IteratorOwner<typename T::const_iterator>::destroy)
      , _equalIter(IteratorOwner<typename T::const_iterator>::equal)
      , _copyIter(IteratorOwner<typename T::const_iterator>::assign)
    {
    }

    QAssociativeIterableImpl()
      : _iterable(nullptr)
      , _iterator(nullptr)
      , _metaType_id_key(QMetaType::UnknownType)
      , _metaType_flags_key(0)
      , _metaType_id_value(QMetaType::UnknownType)
      , _metaType_flags_value(0)
      , _size(nullptr)
      , _find(nullptr)
      , _begin(nullptr)
      , _end(nullptr)
      , _advance(nullptr)
      , _getKey(nullptr)
      , _getValue(nullptr)
      , _destroyIter(nullptr)
      , _equalIter(nullptr)
      , _copyIter(nullptr)
    {
    }

    inline void begin() { _begin(_iterable, &_iterator); }
    inline void end() { _end(_iterable, &_iterator); }
    inline bool equal(const QAssociativeIterableImpl&other) const { return _equalIter(&_iterator, &other._iterator); }
    inline QAssociativeIterableImpl &advance(int i) { _advance(&_iterator, i); return *this; }

    inline void destroyIter() { _destroyIter(&_iterator); }

    inline VariantData getCurrentKey() const { return _getKey(&_iterator, _metaType_id_key, _metaType_flags_key); }
    inline VariantData getCurrentValue() const { return _getValue(&_iterator, _metaType_id_value, _metaType_flags_value); }

    inline void find(const VariantData &key)
    { _find(_iterable, key.data, &_iterator); }

    int size() const { ((_iterable) ? static_cast<void>(0) : qt_assert("_iterable", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 1395)); return _size(_iterable); }

    void copy(const QAssociativeIterableImpl &other)
    {
      *this = other;
      _copyIter(&_iterator, &other._iterator);
    }
};
} template<> class QTypeInfo<QtMetaTypePrivate:: QAssociativeIterableImpl > { public: enum { isSpecialized = true, isComplex = ((((Q_MOVABLE_TYPE)) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QtMetaTypePrivate:: QAssociativeIterableImpl>(), isStatic = ((((Q_MOVABLE_TYPE)) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || (((Q_MOVABLE_TYPE)) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QtMetaTypePrivate:: QAssociativeIterableImpl>(), isLarge = (sizeof(QtMetaTypePrivate:: QAssociativeIterableImpl)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QtMetaTypePrivate:: QAssociativeIterableImpl >::value, isDummy = ((((Q_MOVABLE_TYPE)) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QtMetaTypePrivate:: QAssociativeIterableImpl) }; static inline const char *name() { return "QtMetaTypePrivate:: QAssociativeIterableImpl"; } }; namespace QtMetaTypePrivate {

template<typename From>
struct QAssociativeIterableConvertFunctor
{
    QAssociativeIterableImpl operator()(const From& f) const
    {
        return QAssociativeIterableImpl(&f);
    }
};

class QPairVariantInterfaceImpl
{
    const void *_pair;
    int _metaType_id_first;
    uint _metaType_flags_first;
    int _metaType_id_second;
    uint _metaType_flags_second;

    typedef VariantData (*getFunc)(const void * const *p, int metaTypeId, uint flags);

    getFunc _getFirst;
    getFunc _getSecond;

    template<class T>
    static VariantData getFirstImpl(const void * const *pair, int metaTypeId, uint flags)
    { return VariantData(metaTypeId, &static_cast<const T*>(*pair)->first, flags); }
    template<class T>
    static VariantData getSecondImpl(const void * const *pair, int metaTypeId, uint flags)
    { return VariantData(metaTypeId, &static_cast<const T*>(*pair)->second, flags); }

public:
    template<class T> QPairVariantInterfaceImpl(const T*p)
      : _pair(p)
      , _metaType_id_first(qMetaTypeId<typename T::first_type>())
      , _metaType_flags_first(QTypeInfo<typename T::first_type>::isPointer)
      , _metaType_id_second(qMetaTypeId<typename T::second_type>())
      , _metaType_flags_second(QTypeInfo<typename T::second_type>::isPointer)
      , _getFirst(getFirstImpl<T>)
      , _getSecond(getSecondImpl<T>)
    {
    }

    QPairVariantInterfaceImpl()
      : _pair(nullptr)
      , _metaType_id_first(QMetaType::UnknownType)
      , _metaType_flags_first(0)
      , _metaType_id_second(QMetaType::UnknownType)
      , _metaType_flags_second(0)
      , _getFirst(nullptr)
      , _getSecond(nullptr)
    {
    }

    inline VariantData first() const { return _getFirst(&_pair, _metaType_id_first, _metaType_flags_first); }
    inline VariantData second() const { return _getSecond(&_pair, _metaType_id_second, _metaType_flags_second); }
};
} template<> class QTypeInfo<QtMetaTypePrivate:: QPairVariantInterfaceImpl > { public: enum { isSpecialized = true, isComplex = ((((Q_MOVABLE_TYPE)) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QtMetaTypePrivate:: QPairVariantInterfaceImpl>(), isStatic = ((((Q_MOVABLE_TYPE)) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || (((Q_MOVABLE_TYPE)) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QtMetaTypePrivate:: QPairVariantInterfaceImpl>(), isLarge = (sizeof(QtMetaTypePrivate:: QPairVariantInterfaceImpl)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QtMetaTypePrivate:: QPairVariantInterfaceImpl >::value, isDummy = ((((Q_MOVABLE_TYPE)) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QtMetaTypePrivate:: QPairVariantInterfaceImpl) }; static inline const char *name() { return "QtMetaTypePrivate:: QPairVariantInterfaceImpl"; } }; namespace QtMetaTypePrivate {

template<typename From>
struct QPairVariantInterfaceConvertFunctor;

template<typename T, typename U>
struct QPairVariantInterfaceConvertFunctor<QPair<T, U> >
{
    QPairVariantInterfaceImpl operator()(const QPair<T, U>& f) const
    {
        return QPairVariantInterfaceImpl(&f);
    }
};

template<typename T, typename U>
struct QPairVariantInterfaceConvertFunctor<std::pair<T, U> >
{
    QPairVariantInterfaceImpl operator()(const std::pair<T, U>& f) const
    {
        return QPairVariantInterfaceImpl(&f);
    }
};

}

class QObject;
class QWidget;




template <class T> class QSharedPointer; template <class T> class QWeakPointer; template <class T> class QPointer;

namespace QtPrivate
{
    template<typename T>
    struct IsPointerToTypeDerivedFromQObject
    {
        enum { Value = false };
    };

    
    template<>
    struct IsPointerToTypeDerivedFromQObject<void*>
    {
        enum { Value = false };
    };
    template<>
    struct IsPointerToTypeDerivedFromQObject<const void*>
    {
        enum { Value = false };
    };
    template<>
    struct IsPointerToTypeDerivedFromQObject<QObject*>
    {
        enum { Value = true };
    };

    template<typename T>
    struct IsPointerToTypeDerivedFromQObject<T*>
    {
        typedef qint8 yes_type;
        typedef qint64 no_type;


        static yes_type checkType(QObject* );
#line 1527 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
        static no_type checkType(...);
        static_assert(bool(sizeof(T)), "Type argument of Q_DECLARE_METATYPE(T*) must be fully defined");
        enum { Value = sizeof(checkType(static_cast<T*>(nullptr))) == sizeof(yes_type) };
    };

    template<typename T, typename Enable = void>
    struct IsGadgetHelper { enum { IsRealGadget = false, IsGadgetOrDerivedFrom = false }; };

    template<typename T>
    struct IsGadgetHelper<T, typename T::QtGadgetHelper>
    {
        template <typename X>
        static char checkType(void (X::*)());
        static void *checkType(void (T::*)());
        enum {
            IsRealGadget = sizeof(checkType(&T::qt_check_for_QGADGET_macro)) == sizeof(void *),
            IsGadgetOrDerivedFrom = true
        };
    };

    template<typename T, typename Enable = void>
    struct IsPointerToGadgetHelper { enum { IsRealGadget = false, IsGadgetOrDerivedFrom = false }; };

    template<typename T>
    struct IsPointerToGadgetHelper<T*, typename T::QtGadgetHelper>
    {
        using BaseType = T;
        template <typename X>
        static char checkType(void (X::*)());
        static void *checkType(void (T::*)());
        enum {
            IsRealGadget = !IsPointerToTypeDerivedFromQObject<T*>::Value && sizeof(checkType(&T::qt_check_for_QGADGET_macro)) == sizeof(void *),
            IsGadgetOrDerivedFrom = !IsPointerToTypeDerivedFromQObject<T*>::Value
        };
    };


    template<typename T> char qt_getEnumMetaObject(const T&);

    template<typename T>
    struct IsQEnumHelper {
        static const T &declval();
        
        
        
        
        enum { Value = sizeof(qt_getEnumMetaObject(declval())) == sizeof(QMetaObject*) };
    };
    template<> struct IsQEnumHelper<void> { enum { Value = false }; };

    template<typename T, typename Enable = void>
    struct MetaObjectForType
    {
        static inline const QMetaObject *value() { return nullptr; }
    };
    template<>
    struct MetaObjectForType<void>
    {
        static inline const QMetaObject *value() { return nullptr; }
    };
    template<typename T>
    struct MetaObjectForType<T*, typename std::enable_if<IsPointerToTypeDerivedFromQObject<T*>::Value>::type>
    {
        static inline const QMetaObject *value() { return &T::staticMetaObject; }
    };
    template<typename T>
    struct MetaObjectForType<T, typename std::enable_if<IsGadgetHelper<T>::IsGadgetOrDerivedFrom>::type>
    {
        static inline const QMetaObject *value() { return &T::staticMetaObject; }
    };
    template<typename T>
    struct MetaObjectForType<T, typename std::enable_if<IsPointerToGadgetHelper<T>::IsGadgetOrDerivedFrom>::type>
    {
        static inline const QMetaObject *value() { return &IsPointerToGadgetHelper<T>::BaseType::staticMetaObject; }
    };
    template<typename T>
    struct MetaObjectForType<T, typename std::enable_if<IsQEnumHelper<T>::Value>::type >
    {
        static inline const QMetaObject *value() { return qt_getEnumMetaObject(T()); }
    };

    template<typename T>
    struct IsSharedPointerToTypeDerivedFromQObject
    {
        enum { Value = false };
    };

    template<typename T>
    struct IsSharedPointerToTypeDerivedFromQObject<QSharedPointer<T> > : IsPointerToTypeDerivedFromQObject<T*>
    {
    };

    template<typename T>
    struct IsWeakPointerToTypeDerivedFromQObject
    {
        enum { Value = false };
    };

    template<typename T>
    struct IsWeakPointerToTypeDerivedFromQObject<QWeakPointer<T> > : IsPointerToTypeDerivedFromQObject<T*>
    {
    };

    template<typename T>
    struct IsTrackingPointerToTypeDerivedFromQObject
    {
        enum { Value = false };
    };

    template<typename T>
    struct IsTrackingPointerToTypeDerivedFromQObject<QPointer<T> >
    {
        enum { Value = true };
    };

    template<typename T>
    struct IsSequentialContainer
    {
        enum { Value = false };
    };

    template<typename T>
    struct IsAssociativeContainer
    {
        enum { Value = false };
    };

    template<typename T, bool = QtPrivate::IsSequentialContainer<T>::Value>
    struct SequentialContainerConverterHelper
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };

    template<typename T, bool = QMetaTypeId2<typename T::value_type>::Defined>
    struct ValueTypeIsMetaType
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };

    template<typename T>
    struct SequentialContainerConverterHelper<T, true> : ValueTypeIsMetaType<T>
    {
    };

    template<typename T, bool = QtPrivate::IsAssociativeContainer<T>::Value>
    struct AssociativeContainerConverterHelper
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };

    template<typename T, bool = QMetaTypeId2<typename T::mapped_type>::Defined>
    struct AssociativeValueTypeIsMetaType
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };

    template<typename T, bool = QMetaTypeId2<typename T::key_type>::Defined>
    struct KeyAndValueTypeIsMetaType
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };

    template<typename T>
    struct KeyAndValueTypeIsMetaType<T, true> : AssociativeValueTypeIsMetaType<T>
    {
    };

    template<typename T>
    struct AssociativeContainerConverterHelper<T, true> : KeyAndValueTypeIsMetaType<T>
    {
    };

    template<typename T, bool = QMetaTypeId2<typename T::first_type>::Defined
                                && QMetaTypeId2<typename T::second_type>::Defined>
    struct IsMetaTypePair
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };

    template<typename T>
    struct IsMetaTypePair<T, true>
    {
        inline static bool registerConverter(int id);
    };

    template<typename T>
    struct IsPair
    {
        static bool registerConverter(int)
        {
            return false;
        }
    };
    template<typename T, typename U>
    struct IsPair<QPair<T, U> > : IsMetaTypePair<QPair<T, U> > {};
    template<typename T, typename U>
    struct IsPair<std::pair<T, U> > : IsMetaTypePair<std::pair<T, U> > {};

    template<typename T>
    struct MetaTypePairHelper : IsPair<T> {};

    template<typename T, typename = void>
    struct MetaTypeSmartPointerHelper
    {
        static bool registerConverter(int) { return false; }
    };

    __declspec(dllimport) bool isBuiltinType(const QByteArray &type);
} 

template <typename T, int =
    QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject :
    QtPrivate::IsGadgetHelper<T>::IsRealGadget             ? QMetaType::IsGadget :
    QtPrivate::IsPointerToGadgetHelper<T>::IsRealGadget    ? QMetaType::PointerToGadget :
    QtPrivate::IsQEnumHelper<T>::Value                     ? QMetaType::IsEnumeration : 0>
struct QMetaTypeIdQObject
{
    enum {
        Defined = 0
    };
};

template <typename T>
struct QMetaTypeId : public QMetaTypeIdQObject<T>
{
};

template <typename T>
struct QMetaTypeId2
{
    enum { Defined = QMetaTypeId<T>::Defined, IsBuiltIn=false };
    static inline constexpr int qt_metatype_id() { return QMetaTypeId<T>::qt_metatype_id(); }
};

template <typename T>
struct QMetaTypeId2<const T&> : QMetaTypeId2<T> {};

template <typename T>
struct QMetaTypeId2<T&> { enum {Defined = false }; };

namespace QtPrivate {
    template <typename T, bool Defined = QMetaTypeId2<T>::Defined>
    struct QMetaTypeIdHelper {
        static inline constexpr int qt_metatype_id()
        { return QMetaTypeId2<T>::qt_metatype_id(); }
    };
    template <typename T> struct QMetaTypeIdHelper<T, false> {
        static inline constexpr int qt_metatype_id()
        { return -1; }
    };

    
    template <typename Result, typename... Args>
    struct IsPointerToTypeDerivedFromQObject<Result(*)(Args...)> { enum { Value = false }; };

    template<typename T>
    struct QMetaTypeTypeFlags
    {
        enum { Flags = (QTypeInfoQuery<T>::isRelocatable ? QMetaType::MovableType : 0)
                     | (QTypeInfo<T>::isComplex ? QMetaType::NeedsConstruction : 0)
                     | (QTypeInfo<T>::isComplex ? QMetaType::NeedsDestruction : 0)
                     | (IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject : 0)
                     | (IsSharedPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::SharedPointerToQObject : 0)
                     | (IsWeakPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::WeakPointerToQObject : 0)
                     | (IsTrackingPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::TrackingPointerToQObject : 0)
                     | (std::is_enum<T>::value ? QMetaType::IsEnumeration : 0)
                     | (IsGadgetHelper<T>::IsGadgetOrDerivedFrom ? QMetaType::IsGadget : 0)
                     | (IsPointerToGadgetHelper<T>::IsGadgetOrDerivedFrom ? QMetaType::PointerToGadget : 0)
             };
    };

    template<typename T, bool defined>
    struct MetaTypeDefinedHelper
    {
        enum DefinedType { Defined = defined };
    };

    template<typename SmartPointer>
    struct QSmartPointerConvertFunctor
    {
        QObject* operator()(const SmartPointer &p) const
        {
            return p.operator->();
        }
    };

    
    
    template <typename T>
    struct EnableInternalDataWrap;

    template<typename T>
    struct QSmartPointerConvertFunctor<QWeakPointer<T> >
    {
        QObject* operator()(const QWeakPointer<T> &p) const
        {
            return QtPrivate::EnableInternalDataWrap<T>::internalData(p);
        }
    };
}

template <typename T>
int qRegisterNormalizedMetaType(const ::QByteArray &normalizedTypeName

    , T * dummy = 0
    , typename QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::DefinedType defined = QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::Defined
#line 1852 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
)
{

    ((normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData())) ? static_cast<void>(0) : qt_assert_x("qRegisterNormalizedMetaType", "qRegisterNormalizedMetaType was called with a not normalized type name, please call qRegisterMetaType instead.", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 1855));
#line 1857 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
    const int typedefOf = dummy ? -1 : QtPrivate::QMetaTypeIdHelper<T>::qt_metatype_id();
    if (typedefOf != -1)
        return QMetaType::registerNormalizedTypedef(normalizedTypeName, typedefOf);

    QMetaType::TypeFlags flags(QtPrivate::QMetaTypeTypeFlags<T>::Flags);

    if (defined)
        flags |= QMetaType::WasDeclaredAsMetaType;

    const int id = QMetaType::registerNormalizedType(normalizedTypeName,
                                   QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Destruct,
                                   QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Construct,
                                   int(sizeof(T)),
                                   flags,
                                   QtPrivate::MetaObjectForType<T>::value());

    if (id > 0) {
        QtPrivate::SequentialContainerConverterHelper<T>::registerConverter(id);
        QtPrivate::AssociativeContainerConverterHelper<T>::registerConverter(id);
        QtPrivate::MetaTypePairHelper<T>::registerConverter(id);
        QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter(id);
    }

    return id;
}

template <typename T>
int qRegisterMetaType(const char *typeName

    , T * dummy = nullptr
    , typename QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::DefinedType defined = QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::Defined
#line 1889 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
)
{



    ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);
#line 1896 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
    return qRegisterNormalizedMetaType<T>(normalizedTypeName, dummy, defined);
}


template <typename T>
void qRegisterMetaTypeStreamOperators(const char *typeName

    , T *  = nullptr
#line 1905 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
)
{
    qRegisterMetaType<T>(typeName);
    QMetaType::registerStreamOperators(typeName, QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Save,
                                                 QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Load);
}
#line 1912 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"

template <typename T>
inline constexpr int qMetaTypeId()
{
    static_assert(bool(QMetaTypeId2<T>::Defined), "Type is not registered, please use the Q_DECLARE_METATYPE macro to make it known to Qt's meta-object system");
    return QMetaTypeId2<T>::qt_metatype_id();
}

template <typename T>
inline constexpr int qRegisterMetaType()
{
    return qMetaTypeId<T>();
}











#line 1937 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"


template <typename T>
struct QMetaTypeIdQObject<T*, QMetaType::PointerToQObject>
{
    enum {
        Defined = 1
    };

    static int qt_metatype_id()
    {
        static QBasicAtomicInt metatype_id = { 0 };
        if (const int id = metatype_id.loadAcquire())
            return id;
        const char * const cName = T::staticMetaObject.className();
        QByteArray typeName;
        typeName.reserve(int(strlen(cName)) + 1);
        typeName.append(cName).append('*');
        const int newId = qRegisterNormalizedMetaType<T*>(
                        typeName,
                        reinterpret_cast<T**>(quintptr(-1)));
        metatype_id.storeRelease(newId);
        return newId;
    }
};

template <typename T>
struct QMetaTypeIdQObject<T, QMetaType::IsGadget>
{
    enum {
        Defined = std::is_default_constructible<T>::value
    };

    static int qt_metatype_id()
    {
        static QBasicAtomicInt metatype_id = { 0 };
        if (const int id = metatype_id.loadAcquire())
            return id;
        const char * const cName = T::staticMetaObject.className();
        const int newId = qRegisterNormalizedMetaType<T>(
            cName,
            reinterpret_cast<T*>(quintptr(-1)));
        metatype_id.storeRelease(newId);
        return newId;
    }
};

template <typename T>
struct QMetaTypeIdQObject<T*, QMetaType::PointerToGadget>
{
    enum {
        Defined = 1
    };

    static int qt_metatype_id()
    {
        static QBasicAtomicInt metatype_id = { 0 };
        if (const int id = metatype_id.loadAcquire())
            return id;
        const char * const cName = T::staticMetaObject.className();
        QByteArray typeName;
        typeName.reserve(int(strlen(cName)) + 1);
        typeName.append(cName).append('*');
        const int newId = qRegisterNormalizedMetaType<T*>(
            typeName,
            reinterpret_cast<T**>(quintptr(-1)));
        metatype_id.storeRelease(newId);
        return newId;
    }
};

template <typename T>
struct QMetaTypeIdQObject<T, QMetaType::IsEnumeration>
{
    enum {
        Defined = 1
    };

    static int qt_metatype_id()
    {
        static QBasicAtomicInt metatype_id = { 0 };
        if (const int id = metatype_id.loadAcquire())
            return id;
        const char *eName = qt_getEnumName(T());
        const char *cName = qt_getEnumMetaObject(T())->className();
        QByteArray typeName;
        typeName.reserve(int(strlen(cName) + 2 + strlen(eName)));
        typeName.append(cName).append("::").append(eName);
        const int newId = qRegisterNormalizedMetaType<T>(
            typeName,
            reinterpret_cast<T*>(quintptr(-1)));
        metatype_id.storeRelease(newId);
        return newId;
    }
};
#line 2033 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"


template <typename T>
inline int qRegisterMetaTypeStreamOperators()
{
    int id = qMetaTypeId<T>();
    QMetaType::registerStreamOperators(id, QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Save,
                                           QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Load);
    return id;
}
#line 2044 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"































#line 2076 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"













class QChar; class QString; class QStringList; class QByteArray; class QBitArray; class QDate; class QTime; class QDateTime; class QUrl; class QLocale; class QRect; class QRectF; class QSize; class QSizeF; class QLine; class QLineF; class QPoint; class QPointF; class QRegExp; class QEasingCurve; class QUuid; class QVariant; class QRegularExpression; class QJsonValue; class QJsonObject; class QJsonArray; class QJsonDocument; class QCborValue; class QCborArray; class QCborMap; class QModelIndex; class QPersistentModelIndex;
class QFont; class QPixmap; class QBrush; class QColor; class QPalette; class QIcon; class QImage; class QPolygon; class QRegion; class QBitmap; class QCursor; class QKeySequence; class QPen; class QTextLength; class QTextFormat; class QMatrix; class QTransform; class QMatrix4x4; class QVector2D; class QVector3D; class QVector4D; class QQuaternion; class QPolygonF; class QColorSpace;
class QSizePolicy;



typedef QList<QVariant> QVariantList;
typedef QMap<QString, QVariant> QVariantMap;
typedef QHash<QString, QVariant> QVariantHash;



typedef QList<QByteArray> QByteArrayList;
#line 2103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"











































































namespace QtPrivate {

template<typename T, bool  = false>
struct SharedPointerMetaTypeIdHelper
{
    enum {
        Defined = 0
    };
    static int qt_metatype_id()
    {
        return -1;
    }
};

}





























































 template <class T> class QList;   template <typename T> struct QMetaTypeId< QList<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2254)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QList")) + 1 + tNameLen + 1 + 1); typeName.append("QList", int(sizeof("QList")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QList<T> >( typeName, reinterpret_cast< QList<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QList<T> > { enum { Value = true }; }; }   template <class T> class QVector;   template <typename T> struct QMetaTypeId< QVector<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2254)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QVector")) + 1 + tNameLen + 1 + 1); typeName.append("QVector", int(sizeof("QVector")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QVector<T> >( typeName, reinterpret_cast< QVector<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QVector<T> > { enum { Value = true }; }; }   template <class T> class QQueue;   template <typename T> struct QMetaTypeId< QQueue<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2254)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QQueue")) + 1 + tNameLen + 1 + 1); typeName.append("QQueue", int(sizeof("QQueue")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QQueue<T> >( typeName, reinterpret_cast< QQueue<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QQueue<T> > { enum { Value = true }; }; }   template <class T> class QStack;   template <typename T> struct QMetaTypeId< QStack<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2254)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QStack")) + 1 + tNameLen + 1 + 1); typeName.append("QStack", int(sizeof("QStack")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QStack<T> >( typeName, reinterpret_cast< QStack<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QStack<T> > { enum { Value = true }; }; }   template <class T> class QSet;   template <typename T> struct QMetaTypeId< QSet<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2254)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QSet")) + 1 + tNameLen + 1 + 1); typeName.append("QSet", int(sizeof("QSet")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QSet<T> >( typeName, reinterpret_cast< QSet<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QSet<T> > { enum { Value = true }; }; } 





 template <typename T> struct QMetaTypeId< std::vector<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2260)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("std::vector")) + 1 + tNameLen + 1 + 1); typeName.append("std::vector", int(sizeof("std::vector")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::vector<T> >( typeName, reinterpret_cast< std::vector<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<std::vector<T> > { enum { Value = true }; }; } 
 template <typename T> struct QMetaTypeId< std::list<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadRelaxed()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2261)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("std::list")) + 1 + tNameLen + 1 + 1); typeName.append("std::list", int(sizeof("std::list")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::list<T> >( typeName, reinterpret_cast< std::list<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<std::list<T> > { enum { Value = true }; }; } 






 template <class T1, class T2> class QHash;   template <class T1, class T2> class QMap;   template <class T1, class T2> struct QPair; 















 namespace QtPrivate { template<typename T, typename U> struct IsAssociativeContainer<QHash<T, U> > { enum { Value = true }; }; }   template<typename T, typename U> struct QMetaTypeId< QHash<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2284)); ((uName) ? static_cast<void>(0) : qt_assert("uName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2284)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("QHash")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("QHash", int(sizeof("QHash")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QHash<T, U> >( typeName, reinterpret_cast< QHash<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 
 namespace QtPrivate { template<typename T, typename U> struct IsAssociativeContainer<QMap<T, U> > { enum { Value = true }; }; }   template<typename T, typename U> struct QMetaTypeId< QMap<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2285)); ((uName) ? static_cast<void>(0) : qt_assert("uName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2285)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("QMap")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("QMap", int(sizeof("QMap")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QMap<T, U> >( typeName, reinterpret_cast< QMap<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 
 namespace QtPrivate { template<typename T, typename U> struct IsAssociativeContainer<std::map<T, U> > { enum { Value = true }; }; }   template<typename T, typename U> struct QMetaTypeId< std::map<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2286)); ((uName) ? static_cast<void>(0) : qt_assert("uName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2286)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("std::map")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("std::map", int(sizeof("std::map")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::map<T, U> >( typeName, reinterpret_cast< std::map<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 

 template<typename T, typename U> struct QMetaTypeId< QPair<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2288)); ((uName) ? static_cast<void>(0) : qt_assert("uName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2288)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("QPair")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("QPair", int(sizeof("QPair")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QPair<T, U> >( typeName, reinterpret_cast< QPair<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 
 template<typename T, typename U> struct QMetaTypeId< std::pair<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); ((tName) ? static_cast<void>(0) : qt_assert("tName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2289)); ((uName) ? static_cast<void>(0) : qt_assert("uName", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h", 2289)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("std::pair")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("std::pair", int(sizeof("std::pair")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::pair<T, U> >( typeName, reinterpret_cast< std::pair<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 





 namespace QtPrivate { template<typename T> struct SharedPointerMetaTypeIdHelper<QSharedPointer<T>, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof("QSharedPointer") + 1 + strlen(cName) + 1)); typeName.append("QSharedPointer", int(sizeof("QSharedPointer")) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< QSharedPointer<T> >( typeName, reinterpret_cast< QSharedPointer<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template<typename T> struct MetaTypeSmartPointerHelper<QSharedPointer<T> , typename std::enable_if<IsPointerToTypeDerivedFromQObject<T*>::Value>::type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor<QSharedPointer<T> > o; static const QtPrivate::ConverterFunctor<QSharedPointer<T>, QObject*, QSmartPointerConvertFunctor<QSharedPointer<T> > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template <typename T> struct QMetaTypeId< QSharedPointer<T> > : QtPrivate::SharedPointerMetaTypeIdHelper< QSharedPointer<T>, QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> { };  namespace QtPrivate { template<typename T> struct SharedPointerMetaTypeIdHelper<QWeakPointer<T>, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof("QWeakPointer") + 1 + strlen(cName) + 1)); typeName.append("QWeakPointer", int(sizeof("QWeakPointer")) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< QWeakPointer<T> >( typeName, reinterpret_cast< QWeakPointer<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template<typename T> struct MetaTypeSmartPointerHelper<QWeakPointer<T> , typename std::enable_if<IsPointerToTypeDerivedFromQObject<T*>::Value>::type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor<QWeakPointer<T> > o; static const QtPrivate::ConverterFunctor<QWeakPointer<T>, QObject*, QSmartPointerConvertFunctor<QWeakPointer<T> > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template <typename T> struct QMetaTypeId< QWeakPointer<T> > : QtPrivate::SharedPointerMetaTypeIdHelper< QWeakPointer<T>, QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> { };  namespace QtPrivate { template<typename T> struct SharedPointerMetaTypeIdHelper<QPointer<T>, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof("QPointer") + 1 + strlen(cName) + 1)); typeName.append("QPointer", int(sizeof("QPointer")) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< QPointer<T> >( typeName, reinterpret_cast< QPointer<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template<typename T> struct MetaTypeSmartPointerHelper<QPointer<T> , typename std::enable_if<IsPointerToTypeDerivedFromQObject<T*>::Value>::type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor<QPointer<T> > o; static const QtPrivate::ConverterFunctor<QPointer<T>, QObject*, QSmartPointerConvertFunctor<QPointer<T> > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template <typename T> struct QMetaTypeId< QPointer<T> > : QtPrivate::SharedPointerMetaTypeIdHelper< QPointer<T>, QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> { };





inline QMetaType::QMetaType(const ExtensionFlag extensionFlags, const QMetaTypeInterface *info,
                            TypedConstructor creator,
                            TypedDestructor deleter,
                            SaveOperator saveOp,
                            LoadOperator loadOp,
                            Constructor constructor,
                            Destructor destructor,
                            uint size,
                            uint theTypeFlags,
                            int typeId,
                            const QMetaObject *_metaObject)
    : m_typedConstructor(creator)
    , m_typedDestructor(deleter)
    , m_saveOp(saveOp)
    , m_loadOp(loadOp)
    , m_constructor(constructor)
    , m_destructor(destructor)
    , m_extension(nullptr)
    , m_size(size)
    , m_typeFlags(theTypeFlags)
    , m_extensionFlags(extensionFlags)
    , m_typeId(typeId)
    , m_metaObject(_metaObject)
{
    if ((isExtended(CtorEx) || typeId == QMetaType::Void))
        ctor(info);
}

inline QMetaType::~QMetaType()
{
    if ((isExtended(DtorEx)))
        dtor();
}

inline bool QMetaType::isValid() const
{
    return m_typeId != UnknownType;
}

inline bool QMetaType::isRegistered() const
{
    return isValid();
}

inline int QMetaType::id() const
{
    return m_typeId;
}

inline void *QMetaType::create(const void *copy) const
{
    
    return createExtended(copy);
}

inline void QMetaType::destroy(void *data) const
{
    
    destroyExtended(data);
}

inline void *QMetaType::construct(void *where, const void *copy) const
{
    if ((isExtended(ConstructEx)))
        return constructExtended(where, copy);
    return m_constructor(where, copy);
}

inline void QMetaType::destruct(void *data) const
{
    if ((isExtended(DestructEx)))
        return destructExtended(data);
    if ((!data))
        return;
    m_destructor(data);
}

inline int QMetaType::sizeOf() const
{
    if ((isExtended(SizeEx)))
        return sizeExtended();
    return m_size;
}

inline QMetaType::TypeFlags QMetaType::flags() const
{
    if ((isExtended(FlagsEx)))
        return flagsExtended();
    return QMetaType::TypeFlags(m_typeFlags);
}

inline const QMetaObject *QMetaType::metaObject() const
{
    if ((isExtended(MetaObjectEx)))
        return metaObjectExtended();
    return m_metaObject;
}




 template<> struct QMetaTypeId2<void> { enum { Defined = 1, IsBuiltIn = true, MetaType = 43 }; static inline constexpr int qt_metatype_id() { return 43; } };   template<> struct QMetaTypeId2<bool> { enum { Defined = 1, IsBuiltIn = true, MetaType = 1 }; static inline constexpr int qt_metatype_id() { return 1; } };   template<> struct QMetaTypeId2<int> { enum { Defined = 1, IsBuiltIn = true, MetaType = 2 }; static inline constexpr int qt_metatype_id() { return 2; } };   template<> struct QMetaTypeId2<uint> { enum { Defined = 1, IsBuiltIn = true, MetaType = 3 }; static inline constexpr int qt_metatype_id() { return 3; } };   template<> struct QMetaTypeId2<qlonglong> { enum { Defined = 1, IsBuiltIn = true, MetaType = 4 }; static inline constexpr int qt_metatype_id() { return 4; } };   template<> struct QMetaTypeId2<qulonglong> { enum { Defined = 1, IsBuiltIn = true, MetaType = 5 }; static inline constexpr int qt_metatype_id() { return 5; } };   template<> struct QMetaTypeId2<double> { enum { Defined = 1, IsBuiltIn = true, MetaType = 6 }; static inline constexpr int qt_metatype_id() { return 6; } };   template<> struct QMetaTypeId2<long> { enum { Defined = 1, IsBuiltIn = true, MetaType = 32 }; static inline constexpr int qt_metatype_id() { return 32; } };   template<> struct QMetaTypeId2<short> { enum { Defined = 1, IsBuiltIn = true, MetaType = 33 }; static inline constexpr int qt_metatype_id() { return 33; } };   template<> struct QMetaTypeId2<char> { enum { Defined = 1, IsBuiltIn = true, MetaType = 34 }; static inline constexpr int qt_metatype_id() { return 34; } };   template<> struct QMetaTypeId2<ulong> { enum { Defined = 1, IsBuiltIn = true, MetaType = 35 }; static inline constexpr int qt_metatype_id() { return 35; } };   template<> struct QMetaTypeId2<ushort> { enum { Defined = 1, IsBuiltIn = true, MetaType = 36 }; static inline constexpr int qt_metatype_id() { return 36; } };   template<> struct QMetaTypeId2<uchar> { enum { Defined = 1, IsBuiltIn = true, MetaType = 37 }; static inline constexpr int qt_metatype_id() { return 37; } };   template<> struct QMetaTypeId2<float> { enum { Defined = 1, IsBuiltIn = true, MetaType = 38 }; static inline constexpr int qt_metatype_id() { return 38; } };   template<> struct QMetaTypeId2<signed char> { enum { Defined = 1, IsBuiltIn = true, MetaType = 40 }; static inline constexpr int qt_metatype_id() { return 40; } };   template<> struct QMetaTypeId2<std::nullptr_t> { enum { Defined = 1, IsBuiltIn = true, MetaType = 51 }; static inline constexpr int qt_metatype_id() { return 51; } };   template<> struct QMetaTypeId2<QCborSimpleType> { enum { Defined = 1, IsBuiltIn = true, MetaType = 52 }; static inline constexpr int qt_metatype_id() { return 52; } };   template<> struct QMetaTypeId2<void*> { enum { Defined = 1, IsBuiltIn = true, MetaType = 31 }; static inline constexpr int qt_metatype_id() { return 31; } };   template<> struct QMetaTypeId2<QChar> { enum { Defined = 1, IsBuiltIn = true, MetaType = 7 }; static inline constexpr int qt_metatype_id() { return 7; } };   template<> struct QMetaTypeId2<QString> { enum { Defined = 1, IsBuiltIn = true, MetaType = 10 }; static inline constexpr int qt_metatype_id() { return 10; } };   template<> struct QMetaTypeId2<QStringList> { enum { Defined = 1, IsBuiltIn = true, MetaType = 11 }; static inline constexpr int qt_metatype_id() { return 11; } };   template<> struct QMetaTypeId2<QByteArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 12 }; static inline constexpr int qt_metatype_id() { return 12; } };   template<> struct QMetaTypeId2<QBitArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 13 }; static inline constexpr int qt_metatype_id() { return 13; } };   template<> struct QMetaTypeId2<QDate> { enum { Defined = 1, IsBuiltIn = true, MetaType = 14 }; static inline constexpr int qt_metatype_id() { return 14; } };   template<> struct QMetaTypeId2<QTime> { enum { Defined = 1, IsBuiltIn = true, MetaType = 15 }; static inline constexpr int qt_metatype_id() { return 15; } };   template<> struct QMetaTypeId2<QDateTime> { enum { Defined = 1, IsBuiltIn = true, MetaType = 16 }; static inline constexpr int qt_metatype_id() { return 16; } };   template<> struct QMetaTypeId2<QUrl> { enum { Defined = 1, IsBuiltIn = true, MetaType = 17 }; static inline constexpr int qt_metatype_id() { return 17; } };   template<> struct QMetaTypeId2<QLocale> { enum { Defined = 1, IsBuiltIn = true, MetaType = 18 }; static inline constexpr int qt_metatype_id() { return 18; } };   template<> struct QMetaTypeId2<QRect> { enum { Defined = 1, IsBuiltIn = true, MetaType = 19 }; static inline constexpr int qt_metatype_id() { return 19; } };   template<> struct QMetaTypeId2<QRectF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 20 }; static inline constexpr int qt_metatype_id() { return 20; } };   template<> struct QMetaTypeId2<QSize> { enum { Defined = 1, IsBuiltIn = true, MetaType = 21 }; static inline constexpr int qt_metatype_id() { return 21; } };   template<> struct QMetaTypeId2<QSizeF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 22 }; static inline constexpr int qt_metatype_id() { return 22; } };   template<> struct QMetaTypeId2<QLine> { enum { Defined = 1, IsBuiltIn = true, MetaType = 23 }; static inline constexpr int qt_metatype_id() { return 23; } };   template<> struct QMetaTypeId2<QLineF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 24 }; static inline constexpr int qt_metatype_id() { return 24; } };   template<> struct QMetaTypeId2<QPoint> { enum { Defined = 1, IsBuiltIn = true, MetaType = 25 }; static inline constexpr int qt_metatype_id() { return 25; } };   template<> struct QMetaTypeId2<QPointF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 26 }; static inline constexpr int qt_metatype_id() { return 26; } };   template<> struct QMetaTypeId2<QRegExp> { enum { Defined = 1, IsBuiltIn = true, MetaType = 27 }; static inline constexpr int qt_metatype_id() { return 27; } };   template<> struct QMetaTypeId2<QEasingCurve> { enum { Defined = 1, IsBuiltIn = true, MetaType = 29 }; static inline constexpr int qt_metatype_id() { return 29; } };   template<> struct QMetaTypeId2<QUuid> { enum { Defined = 1, IsBuiltIn = true, MetaType = 30 }; static inline constexpr int qt_metatype_id() { return 30; } };   template<> struct QMetaTypeId2<QVariant> { enum { Defined = 1, IsBuiltIn = true, MetaType = 41 }; static inline constexpr int qt_metatype_id() { return 41; } };   template<> struct QMetaTypeId2<QRegularExpression> { enum { Defined = 1, IsBuiltIn = true, MetaType = 44 }; static inline constexpr int qt_metatype_id() { return 44; } };   template<> struct QMetaTypeId2<QJsonValue> { enum { Defined = 1, IsBuiltIn = true, MetaType = 45 }; static inline constexpr int qt_metatype_id() { return 45; } };   template<> struct QMetaTypeId2<QJsonObject> { enum { Defined = 1, IsBuiltIn = true, MetaType = 46 }; static inline constexpr int qt_metatype_id() { return 46; } };   template<> struct QMetaTypeId2<QJsonArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 47 }; static inline constexpr int qt_metatype_id() { return 47; } };   template<> struct QMetaTypeId2<QJsonDocument> { enum { Defined = 1, IsBuiltIn = true, MetaType = 48 }; static inline constexpr int qt_metatype_id() { return 48; } };   template<> struct QMetaTypeId2<QCborValue> { enum { Defined = 1, IsBuiltIn = true, MetaType = 53 }; static inline constexpr int qt_metatype_id() { return 53; } };   template<> struct QMetaTypeId2<QCborArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 54 }; static inline constexpr int qt_metatype_id() { return 54; } };   template<> struct QMetaTypeId2<QCborMap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 55 }; static inline constexpr int qt_metatype_id() { return 55; } };   template<> struct QMetaTypeId2<QModelIndex> { enum { Defined = 1, IsBuiltIn = true, MetaType = 42 }; static inline constexpr int qt_metatype_id() { return 42; } };   template<> struct QMetaTypeId2<QPersistentModelIndex> { enum { Defined = 1, IsBuiltIn = true, MetaType = 50 }; static inline constexpr int qt_metatype_id() { return 50; } };   template<> struct QMetaTypeId2<QObject*> { enum { Defined = 1, IsBuiltIn = true, MetaType = 39 }; static inline constexpr int qt_metatype_id() { return 39; } };   template<> struct QMetaTypeId2<QVariantMap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 8 }; static inline constexpr int qt_metatype_id() { return 8; } };   template<> struct QMetaTypeId2<QVariantList> { enum { Defined = 1, IsBuiltIn = true, MetaType = 9 }; static inline constexpr int qt_metatype_id() { return 9; } };   template<> struct QMetaTypeId2<QVariantHash> { enum { Defined = 1, IsBuiltIn = true, MetaType = 28 }; static inline constexpr int qt_metatype_id() { return 28; } };   template<> struct QMetaTypeId2<QByteArrayList> { enum { Defined = 1, IsBuiltIn = true, MetaType = 49 }; static inline constexpr int qt_metatype_id() { return 49; } };   template<> struct QMetaTypeId2<QFont> { enum { Defined = 1, IsBuiltIn = true, MetaType = 64 }; static inline constexpr int qt_metatype_id() { return 64; } };   template<> struct QMetaTypeId2<QPixmap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 65 }; static inline constexpr int qt_metatype_id() { return 65; } };   template<> struct QMetaTypeId2<QBrush> { enum { Defined = 1, IsBuiltIn = true, MetaType = 66 }; static inline constexpr int qt_metatype_id() { return 66; } };   template<> struct QMetaTypeId2<QColor> { enum { Defined = 1, IsBuiltIn = true, MetaType = 67 }; static inline constexpr int qt_metatype_id() { return 67; } };   template<> struct QMetaTypeId2<QPalette> { enum { Defined = 1, IsBuiltIn = true, MetaType = 68 }; static inline constexpr int qt_metatype_id() { return 68; } };   template<> struct QMetaTypeId2<QIcon> { enum { Defined = 1, IsBuiltIn = true, MetaType = 69 }; static inline constexpr int qt_metatype_id() { return 69; } };   template<> struct QMetaTypeId2<QImage> { enum { Defined = 1, IsBuiltIn = true, MetaType = 70 }; static inline constexpr int qt_metatype_id() { return 70; } };   template<> struct QMetaTypeId2<QPolygon> { enum { Defined = 1, IsBuiltIn = true, MetaType = 71 }; static inline constexpr int qt_metatype_id() { return 71; } };   template<> struct QMetaTypeId2<QRegion> { enum { Defined = 1, IsBuiltIn = true, MetaType = 72 }; static inline constexpr int qt_metatype_id() { return 72; } };   template<> struct QMetaTypeId2<QBitmap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 73 }; static inline constexpr int qt_metatype_id() { return 73; } };   template<> struct QMetaTypeId2<QCursor> { enum { Defined = 1, IsBuiltIn = true, MetaType = 74 }; static inline constexpr int qt_metatype_id() { return 74; } };   template<> struct QMetaTypeId2<QKeySequence> { enum { Defined = 1, IsBuiltIn = true, MetaType = 75 }; static inline constexpr int qt_metatype_id() { return 75; } };   template<> struct QMetaTypeId2<QPen> { enum { Defined = 1, IsBuiltIn = true, MetaType = 76 }; static inline constexpr int qt_metatype_id() { return 76; } };   template<> struct QMetaTypeId2<QTextLength> { enum { Defined = 1, IsBuiltIn = true, MetaType = 77 }; static inline constexpr int qt_metatype_id() { return 77; } };   template<> struct QMetaTypeId2<QTextFormat> { enum { Defined = 1, IsBuiltIn = true, MetaType = 78 }; static inline constexpr int qt_metatype_id() { return 78; } };   template<> struct QMetaTypeId2<QMatrix> { enum { Defined = 1, IsBuiltIn = true, MetaType = 79 }; static inline constexpr int qt_metatype_id() { return 79; } };   template<> struct QMetaTypeId2<QTransform> { enum { Defined = 1, IsBuiltIn = true, MetaType = 80 }; static inline constexpr int qt_metatype_id() { return 80; } };   template<> struct QMetaTypeId2<QMatrix4x4> { enum { Defined = 1, IsBuiltIn = true, MetaType = 81 }; static inline constexpr int qt_metatype_id() { return 81; } };   template<> struct QMetaTypeId2<QVector2D> { enum { Defined = 1, IsBuiltIn = true, MetaType = 82 }; static inline constexpr int qt_metatype_id() { return 82; } };   template<> struct QMetaTypeId2<QVector3D> { enum { Defined = 1, IsBuiltIn = true, MetaType = 83 }; static inline constexpr int qt_metatype_id() { return 83; } };   template<> struct QMetaTypeId2<QVector4D> { enum { Defined = 1, IsBuiltIn = true, MetaType = 84 }; static inline constexpr int qt_metatype_id() { return 84; } };   template<> struct QMetaTypeId2<QQuaternion> { enum { Defined = 1, IsBuiltIn = true, MetaType = 85 }; static inline constexpr int qt_metatype_id() { return 85; } };   template<> struct QMetaTypeId2<QPolygonF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 86 }; static inline constexpr int qt_metatype_id() { return 86; } };   template<> struct QMetaTypeId2<QColorSpace> { enum { Defined = 1, IsBuiltIn = true, MetaType = 87 }; static inline constexpr int qt_metatype_id() { return 87; } };   template<> struct QMetaTypeId2<QSizePolicy> { enum { Defined = 1, IsBuiltIn = true, MetaType = 121 }; static inline constexpr int qt_metatype_id() { return 121; } }; 

 template <> struct QMetaTypeId< QtMetaTypePrivate::QSequentialIterableImpl > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QtMetaTypePrivate::QSequentialIterableImpl >("QtMetaTypePrivate::QSequentialIterableImpl", reinterpret_cast< QtMetaTypePrivate::QSequentialIterableImpl *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 
 template <> struct QMetaTypeId< QtMetaTypePrivate::QAssociativeIterableImpl > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QtMetaTypePrivate::QAssociativeIterableImpl >("QtMetaTypePrivate::QAssociativeIterableImpl", reinterpret_cast< QtMetaTypePrivate::QAssociativeIterableImpl *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 
 template <> struct QMetaTypeId< QtMetaTypePrivate::QPairVariantInterfaceImpl > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QtMetaTypePrivate::QPairVariantInterfaceImpl >("QtMetaTypePrivate::QPairVariantInterfaceImpl", reinterpret_cast< QtMetaTypePrivate::QPairVariantInterfaceImpl *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; 



template <typename T>
inline bool QtPrivate::IsMetaTypePair<T, true>::registerConverter(int id)
{
    const int toId = qMetaTypeId<QtMetaTypePrivate::QPairVariantInterfaceImpl>();
    if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
        QtMetaTypePrivate::QPairVariantInterfaceConvertFunctor<T> o;
        static const QtPrivate::ConverterFunctor<T,
                                    QtMetaTypePrivate::QPairVariantInterfaceImpl,
                                    QtMetaTypePrivate::QPairVariantInterfaceConvertFunctor<T> > f(o);
        return QMetaType::registerConverterFunction(&f, id, toId);
    }
    return true;
}

namespace QtPrivate {
    template<typename T>
    struct ValueTypeIsMetaType<T, true>
    {
        static bool registerConverter(int id)
        {
            const int toId = qMetaTypeId<QtMetaTypePrivate::QSequentialIterableImpl>();
            if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
                QtMetaTypePrivate::QSequentialIterableConvertFunctor<T> o;
                static const QtPrivate::ConverterFunctor<T,
                        QtMetaTypePrivate::QSequentialIterableImpl,
                QtMetaTypePrivate::QSequentialIterableConvertFunctor<T> > f(o);
                return QMetaType::registerConverterFunction(&f, id, toId);
            }
            return true;
        }
    };

    template<typename T>
    struct AssociativeValueTypeIsMetaType<T, true>
    {
        static bool registerConverter(int id)
        {
            const int toId = qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>();
            if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
                QtMetaTypePrivate::QAssociativeIterableConvertFunctor<T> o;
                static const QtPrivate::ConverterFunctor<T,
                                            QtMetaTypePrivate::QAssociativeIterableImpl,
                                            QtMetaTypePrivate::QAssociativeIterableConvertFunctor<T> > f(o);
                return QMetaType::registerConverterFunction(&f, id, toId);
            }
            return true;
        }
    };
}



#line 2463 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qmetatype.h"
#pragma external_header(pop)
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject_impl.h"
















































#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject_impl.h"




namespace QtPrivate {
    









    template <typename ArgList> struct TypesAreDeclaredMetaType { enum { Value = false }; };
    template <> struct TypesAreDeclaredMetaType<List<>> { enum { Value = true }; };
    template <typename Arg, typename... Tail> struct TypesAreDeclaredMetaType<List<Arg, Tail...> >
    { enum { Value = QMetaTypeId2<Arg>::Defined && TypesAreDeclaredMetaType<List<Tail...>>::Value }; };

    template <typename ArgList, bool Declared = TypesAreDeclaredMetaType<ArgList>::Value > struct ConnectionTypes
    { static const int *types() { return nullptr; } };
    template <> struct ConnectionTypes<List<>, true>
    { static const int *types() { return nullptr; } };
    template <typename... Args> struct ConnectionTypes<List<Args...>, true>
    { static const int *types() { static const int t[sizeof...(Args) + 1] = { (QtPrivate::QMetaTypeIdHelper<Args>::qt_metatype_id())..., 0 }; return t; } };

    
    
    template<typename Func, typename Args, typename R> class QStaticSlotObject : public QSlotObjectBase
    {
        typedef QtPrivate::FunctionPointer<Func> FuncType;
        Func function;
        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
        {
            switch (which) {
            case Destroy:
                delete static_cast<QStaticSlotObject*>(this_);
                break;
            case Call:
                FuncType::template call<Args, R>(static_cast<QStaticSlotObject*>(this_)->function, r, a);
                break;
            case Compare:   
            case NumOperations:
                (void)ret;;
            }
        }
    public:
        explicit QStaticSlotObject(Func f) : QSlotObjectBase(&impl), function(f) {}
    };
}




#line 106 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject_impl.h"
#pragma external_header(pop)
#line 57 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"





#pragma once






#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ratio"
#line 286 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ratio"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"






#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.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 {
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 70 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     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>,
            "N4950 [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 231 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

        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 379 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     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 419 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> >
    [[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>)  {
        
        if (_Dur < duration<_Rep, _Period>::zero()) {
            return -_Dur;
        } else {
            return _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 522 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     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 568 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     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 605 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     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 661 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"

     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;




#line 673 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"





#line 679 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"
        [[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;
            constexpr long long _TwentyFourMHz = 24'000'000;
            
            if (_Freq == _TenMHz) [[likely]] {
                
                
                
                static_assert(period::den % _TenMHz == 0, "It should never fail.");
                constexpr long long _Multiplier = period::den / _TenMHz;
                return time_point(duration(_Ctr * _Multiplier));
            } else if (_Freq == _TwentyFourMHz)  {
                
                const long long _Whole = (_Ctr / _TwentyFourMHz) * period::den;
                const long long _Part  = (_Ctr % _TwentyFourMHz) * period::den / _TwentyFourMHz;
                return time_point(duration(_Whole + _Part));
            } 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 _Rep, class _Period>
[[nodiscard]] bool _To_timespec64_sys_10_day_clamped(
    _timespec64& _Ts64, 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::duration{_Xtime_get_ticks()};
    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);
    _Ts64.tv_sec              = _Whole_seconds.count();
    _Tx0 -= _Whole_seconds;
    _Ts64.tv_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);
        }
    } 
} 

namespace chrono {
     using namespace literals::chrono_literals;
} 
}



#pragma warning(pop)
#pragma pack(pop)
#line 817 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"
#line 818 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_chrono.hpp"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_system_error_abi.hpp"
#line 42 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_system_error_abi.hpp"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cerrno"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cerrno"
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cerrno"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdexcept"
};

[[noreturn]] inline void _Throw_range_error(const char* const _Message) {
    throw range_error{_Message};
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 174 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdexcept"
#line 175 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stdexcept"
#pragma external_header(pop)
#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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**);


extern "C++"  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 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcall_once.h"
#line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcall_once.h"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xerrc.h"
#line 110 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xerrc.h"
#pragma external_header(pop)
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"


#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"



#line 24 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

namespace _Ensure_adl {
    void make_error_code()      = delete;
    void make_error_condition() = delete;
} 

 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:





#pragma warning(push)
#pragma warning(disable : 4355) 
    constexpr error_category() noexcept : _Addr(this) {}
#pragma warning(pop)
#line 87 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"

    constexpr 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 _Bit_cast<uintptr_t>(_Addr) == _Bit_cast<uintptr_t>(_Right._Addr);
#line 106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
    }





#line 113 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"


    [[nodiscard]] strong_ordering operator<=>(const error_category& _Right) const noexcept {
        return _Bit_cast<uintptr_t>(_Addr) <=> _Bit_cast<uintptr_t>(_Right._Addr);
    }








#line 127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"

    error_category(const error_category&)            = delete;
    error_category& operator=(const error_category&) = delete;

protected:



    union _Addr_storage {
    private:
        uintptr_t _Num;
        error_category* _Ptr;

    public:
        constexpr explicit _Addr_storage(const uintptr_t _Addr_num) noexcept : _Num(_Addr_num) {}
        constexpr explicit _Addr_storage(error_category* const _Addr_ptr) noexcept : _Ptr(_Addr_ptr) {}

        
        constexpr _Addr_storage& operator=(const uintptr_t _Addr_num) noexcept {
            _Num = _Addr_num;
            return *this;
        }
    };
    ;
    ;

    _Addr_storage _Addr;
#line 155 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"

    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 169 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        using _Ensure_adl::make_error_code;
        *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 {
        using _Ensure_adl::make_error_code;
        *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 239 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
















#line 256 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#line 257 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        using _Ensure_adl::make_error_condition;
        *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 {
        using _Ensure_adl::make_error_condition;
        *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 327 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"




#line 332 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"

    
    
    
    friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept;




#line 342 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#line 343 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 415 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Ec) noexcept {
    return error_code(static_cast<int>(_Ec), ::std:: generic_category());
}

 [[nodiscard]] inline error_code make_error_code(io_errc _Ec) noexcept {
    return error_code(static_cast<int>(_Ec), ::std:: iostream_category());
}

 [[nodiscard]] inline error_condition make_error_condition(errc _Ec) noexcept {
    return error_condition(static_cast<int>(_Ec), ::std:: generic_category());
}

 [[nodiscard]] inline error_condition make_error_condition(io_errc _Ec) noexcept {
    return error_condition(static_cast<int>(_Ec), ::std:: iostream_category());
}

template <>
struct hash<error_code> {
    using _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 suppress this warning.")]] = error_code;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[nodiscard]] size_t operator()(const error_code& _Keyval) const noexcept {
        return hash<int>{}(_Keyval.value());
    }
};

template <>
struct hash<error_condition> {
    using _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 suppress this warning.")]] = error_condition;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[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) : runtime_error(_Errcode.message()), _Mycode(_Errcode) {}

    _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 519 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
};

[[noreturn]] inline void _Throw_system_error(const errc _Ec) {
    throw system_error{::std:: make_error_code(_Ec)};
}

extern "C++"  const char* __cdecl _Syserror_map(int);
extern "C++"  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 {
        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 647 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
template <class _Ty>
[[nodiscard]] const _Ty& _Immortalize_memcpy_image() noexcept {
    static constexpr _Ty _Static;
    return _Static;
}















































#line 700 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>();
}
}


extern "C" {
enum class __std_win_error : unsigned long;
}

namespace std {







[[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)};
}
}
#line 736 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"







#pragma warning(pop)
#pragma pack(pop)
#line 746 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#line 747 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\system_error"
#pragma external_header(pop)
#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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    )




extern "C" {
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, 
    _Reparse_tag_invalid       = 4393L, 
    _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)); }

extern "C" {
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)); }

extern "C" {
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 (::std:: _Bitmask_includes_any(_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)); }

extern "C" {
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)); }

extern "C" {
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)); }

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_write_reparse_data_buffer(
      __std_fs_file_handle _Handle,   const __std_fs_reparse_data_buffer* _Buffer) noexcept;

[[nodiscard]] bool __stdcall __std_fs_is_junction_from_reparse_data_buffer(
      const __std_fs_reparse_data_buffer* _Buffer) 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 397 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xfilesystem_abi.h"
#line 398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xfilesystem_abi.h"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"

#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__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    )




extern "C" {

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;
};

enum class __std_tzdb_sys_info_type : char {
    
    
    
    
    _Full = '\0',
    _Offset_only,
    _Offset_and_range,
};

[[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(__declspec(guard(overflow)) 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 164 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_tzdb.hpp"
#line 165 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_tzdb.hpp"
#pragma external_header(pop)
#line 21 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

    [[nodiscard]] bool operator==(_Default_sentinel) const noexcept {
        return _Ptr == nullptr;
    }





#line 80 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 135, 0, "%s", "cannot dereference value-initialized forward_list iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized forward_list iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 135, 0); } while (false); } ; } while (false);
        do { if (this->_Ptr != _Mycont->_Before_head()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 136, 0, "%s", "cannot dereference forward_list before_begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference forward_list before_begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 136, 0); } while (false); } ; } while (false);
#line 138 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

        return this->_Ptr->_Myval;
    }

    _Flist_const_iterator& operator++() noexcept {

        do { if (this->_Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 144, 0, "%s", "forward_list iterator not incrementable")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list iterator not incrementable\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 144, 0); } while (false); } ; } while (false);
#line 146 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 159, 0, "%s", "forward_list iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 159, 0); } while (false); } ; } while (false);
#line 161 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

        return this->_Ptr == _Right._Ptr;
    }





#line 170 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"


    friend void _Verify_range(const _Flist_const_iterator& _First, const _Flist_const_iterator& _Last) noexcept {
        do { if (_First._Getcont() == _Last._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 174, 0, "%s", "forward_list iterators in range are from different containers")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list iterators in range are from different containers\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 174, 0); } while (false); } ; } while (false);
#line 175 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
    }
#line 177 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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 = _Returns_exactly<_Value_type>(); 

    _Flist_node()                              = default;
    _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)));
    }


    void _Orphan_ptr(_Nodeptr _Ptr) noexcept { 
        const auto _BHead = _Before_head();
        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
        while (*_Pnext) {
            const auto _Pnextptr = static_cast<_Flist_const_iterator<_Flist_val>&>(**_Pnext)._Ptr;
            if (_Pnextptr == _BHead || (_Ptr != nullptr && _Pnextptr != _Ptr)) {
                _Pnext = &(*_Pnext)->_Mynextiter;
            } else { 
                (*_Pnext)->_Myproxy = nullptr;
                *_Pnext             = (*_Pnext)->_Mynextiter;
            }
        }
    }
#line 301 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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 (!_Debug_lt_pred(_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 || !_Debug_lt_pred(_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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
                                    "because of [container.requirements].");

    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, _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(__declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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());
    }

















#line 629 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

    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);
    }

    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(static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al), static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Right_al));
                _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 707 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
    }

    template <class... _Valty>
    iterator emplace_after(const_iterator _Where, _Valty&&... _Val) { 

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 713, 0, "%s", "forward_list emplace_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list emplace_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 713, 0); } while (false); } ; } while (false);
#line 714 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 715 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 = static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal());
        _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();

        auto&& _Alproxy = static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Getal());
        _Delete_plain_internal(_Alproxy, _Mypair._Myval2._Myproxy);
#line 759 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
    }

    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(
                    static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Al), static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Right_al));
            }
        }

        _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(__declspec(guard(overflow)) 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;

                    _Mypair._Myval2._Orphan_ptr(_Next);
#line 866 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
                    _Node::_Freenode(_Al, _Next);
                    _Next = _Nextafter;
                } while (_Next);

                return;
            }

            _Ptr = _Next;
            --_Newsize;
        }
    }

public:
    void resize(__declspec(guard(overflow)) size_type _Newsize) {
        _Resize(_Newsize);
    }

    void resize(__declspec(guard(overflow)) 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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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  {

        do { if (_Mypair._Myval2._Myhead != nullptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 902, 0, "%s", "front() called on empty forward_list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty forward_list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 902, 0); } while (false); } ; } while (false);
#line 904 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

        return _Mypair._Myval2._Myhead->_Myval;
    }

    [[nodiscard]] const_reference front() const noexcept  {

        do { if (_Mypair._Myval2._Myhead != nullptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 910, 0, "%s", "front() called on empty forward_list")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty forward_list\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 910, 0); } while (false); } ; } while (false);
#line 912 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

        return _Mypair._Myval2._Myhead->_Myval;
    }

    void push_front(const _Ty& _Val) {
        _Insert_after(_Mypair._Myval2._Before_head(), _Val);
    }






#line 926 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

    void pop_front() noexcept  {
        _Erase_after(_Mypair._Myval2._Before_head());
    }

private:
    template <class _UIter, class _Sentinel>
    void _Assign_unchecked(_UIter _UFirst, const _Sentinel _ULast) {
        auto _Myfirst = _Mypair._Myval2._Before_head();
        for (; _UFirst != _ULast; ++_UFirst) {
            const auto _Next = _Myfirst->_Next;
            if (!_Next) {
                _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
                _Insert_op._Append_range_unchecked(::std:: move(_UFirst), _ULast);
                _Insert_op._Attach_after(_Myfirst);
                return;
            }

            _Next->_Myval = *_UFirst;
            _Myfirst      = _Next;
        }

        for (auto _To_delete = ::std:: exchange(_Myfirst->_Next, nullptr); _To_delete;) {
            const auto _Next = _To_delete->_Next;

            _Mypair._Myval2._Orphan_ptr(_To_delete);
#line 953 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
    }






#line 971 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

    void assign(__declspec(guard(overflow)) size_type _Count, const _Ty& _Val) {
        clear();
        insert_after(before_begin(), _Count, _Val);
    }

    iterator insert_after(const_iterator _Where, const _Ty& _Val) { 

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 980, 0, "%s", "forward_list insert_after location incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list insert_after location incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 980, 0); } while (false); } ; } while (false);
#line 981 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 982 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        _Insert_after(_Where._Ptr, _Val);
        return _Make_iter(_Where._Ptr->_Next);
    }

    iterator insert_after(const_iterator _Where, __declspec(guard(overflow)) size_type _Count, const _Ty& _Val) {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 990, 0, "%s", "forward_list insert_after location incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list insert_after location incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 990, 0); } while (false); } ; } while (false);
#line 991 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 992 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }

private:
    template <class _Iter, class _Sent>
    iterator _Insert_range_after(_Nodeptr _Pnode, _Iter _First, const _Sent _Last) {
        
        if (_First == _Last) {
            return _Make_iter(_Pnode);
        }

        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_range_unchecked(::std:: move(_First), _Last);
        return _Make_iter(_Insert_op._Attach_after(_Pnode));
    }

public:
    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    iterator insert_after(const_iterator _Where, _Iter _First, _Iter _Last) {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1021, 0, "%s", "forward_list insert_after location incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list insert_after location incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1021, 0); } while (false); } ; } while (false);
#line 1022 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 1023 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        _Adl_verify_range(_First, _Last);
        return _Insert_range_after(_Where._Ptr, _Get_unwrapped(_First), _Get_unwrapped(_Last));
    }










#line 1037 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

private:
    void _Erase_after(_Nodeptr _Pnode) noexcept { 
        auto _Subject = _Pnode->_Next;

        _Mypair._Myval2._Orphan_ptr(_Subject);
#line 1044 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        _Pnode->_Next = _Subject->_Next;
        _Node::_Freenode(_Getal(), _Subject);
    }

public:
    iterator erase_after(const_iterator _Where) noexcept  {

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1052, 0, "%s", "forward_list erase_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list erase_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1052, 0); } while (false); } ; } while (false);
#line 1053 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 1054 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        _Erase_after(_Where._Ptr);
        return _Make_iter(_Where._Ptr->_Next);
    }

    iterator erase_after(const_iterator _First, const_iterator _Last) noexcept  {

        const auto _Mycont = ::std:: addressof(_Mypair._Myval2);
        do { if (_First._Getcont() == _Mycont && _Last._Getcont() == _Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1062, 0, "%s", "forward_list erase_after iterator range from incorrect container")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list erase_after iterator range from incorrect container\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1062, 0); } while (false); } ; } while (false);
#line 1063 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 1064 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        auto _Before = _First._Ptr;
        if (_Before != _Last._Ptr) {
            auto& _Al = _Getal();
            for (;;) {
                const auto _Subject = _Before->_Next;
                if (_Subject == _Last._Ptr) {
                    break;
                }


                _Mypair._Myval2._Orphan_ptr(_Subject);
#line 1076 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
                _Before->_Next = _Subject->_Next;
                _Node::_Freenode(_Al, _Subject);
            }
        }

        return _Make_iter(_Last._Ptr);
    }

    void clear() noexcept { 

        _Mypair._Myval2._Orphan_ptr(nullptr);
#line 1088 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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  {
        using ::std:: swap;
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Swap_proxy_and_iterators(_Right);
            swap(_Mypair._Myval2._Myhead, _Right._Mypair._Myval2._Myhead); 
        }
    }

    void splice_after(const_iterator _Where, forward_list& _Right) noexcept  {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1112, 0, "%s", "forward_list splice_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list splice_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1112, 0); } while (false); } ; } while (false);
#line 1113 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 1114 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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  {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1129, 0, "%s", "forward_list splice_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list splice_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1129, 0); } while (false); } ; } while (false);
#line 1130 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        do { if (_First._Getcont() == ::std:: addressof(_Right._Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1131, 0, "%s", "forward_list splice_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list splice_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1131, 0); } while (false); } ; } while (false);
#line 1132 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        do { if (_First._Ptr->_Next != nullptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1132, 0, "%s", "forward_list splice_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list splice_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1132, 0); } while (false); } ; } while (false);
#line 1134 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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
     {
        

        do { if (_Where._Getcont() == ::std:: addressof(_Mypair._Myval2)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1148, 0, "%s", "forward_list splice_after iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list splice_after iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1148, 0); } while (false); } ; } while (false);
#line 1149 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        const auto _Rightcont = ::std:: addressof(_Right._Mypair._Myval2);
        do { if (_First._Getcont() == _Rightcont && _Last._Getcont() == _Rightcont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1151, 0, "%s", "forward_list splice_after range outside right")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list splice_after range outside right\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1151, 0); } while (false); } ; } while (false);
#line 1152 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 1153 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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     = nullptr;
            _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;

                _List._Mypair._Myval2._Orphan_ptr(_Target);
#line 1197 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1264 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 

        _Debug_order_unchecked(_Unchecked_begin(), _Default_sentinel{}, _Pred);
#line 1290 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        if (this == ::std:: addressof(_Right)) {
            return;
        }

        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;

        _Debug_order_unchecked(_Right._Unchecked_begin(), _Default_sentinel{}, _Pred);
        if constexpr (!_Alnode_traits::is_always_equal::value) {
            do { if (_Getal() == _Right._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1299, 0, "%s", "forward_list allocators incompatible for merge")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list allocators incompatible for merge\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1299, 0); } while (false); } ; } while (false);
        }
#line 1302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

        if (!_My_data._Myhead) {
            

            {
                _Lockit _Lock(3);
                _Transfer_non_before_begin_ownership(_Right);
            } 
#line 1311 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
            _My_data._Myhead    = _Right_data._Myhead;
            _Right_data._Myhead = nullptr;
            return;
        }


        constexpr bool _Noexcept =
            noexcept(_Debug_lt_pred(_Pred, _My_data._Myhead->_Myval, _Right_data._Myhead->_Myval));
        if constexpr (_Noexcept) {
            
            
            _Lockit _Lock(3);
            _Transfer_non_before_begin_ownership(_Right);
        } 
#line 1326 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (_Debug_lt_pred(_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 (!_Debug_lt_pred(_Pred, _Run_end->_Myval, _First1->_Myval)) {
                    
                    
                    break;
                }

                _BRun_end = _Run_end;
            }


            if constexpr (!_Noexcept) {
                _Lockit _Lock(3);
                for (auto _Next = _First2; _Next != _Run_end; _Next = _Next->_Next) {
                    _Transfer_ownership(_Right, _Next);
                }
            } 
#line 1378 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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:

    void _Transfer_non_before_begin_ownership(forward_list& _Right) noexcept {
        
        const auto _Mycont            = ::std:: addressof(_Mypair._Myval2);
        const auto _Myproxy           = _Mycont->_Myproxy;
        const auto _Right_before_head = _Right._Mypair._Myval2._Before_head();
        _Iterator_base12** _Pnext     = &_Right._Mypair._Myval2._Myproxy->_Myfirstiter;
        while (*_Pnext) {
            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
            if (_Pnextptr == _Right_before_head) {
                _Pnext = &(*_Pnext)->_Mynextiter;
            } else { 
                const auto _Extracted   = *_Pnext;
                *_Pnext                 = (*_Pnext)->_Mynextiter;
                _Extracted->_Myproxy    = _Myproxy;
                _Extracted->_Mynextiter = _Myproxy->_Myfirstiter;
                _Myproxy->_Myfirstiter  = _Extracted;
            }
        }
    }

    void _Transfer_ownership(forward_list& _Right, _Nodeptr _Target) noexcept {
        
        const auto _Mycont        = ::std:: addressof(_Mypair._Myval2);
        const auto _Myproxy       = _Mycont->_Myproxy;
        _Iterator_base12** _Pnext = &_Right._Mypair._Myval2._Myproxy->_Myfirstiter;
        while (*_Pnext) {
            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
            if (_Pnextptr != _Target) {
                _Pnext = &(*_Pnext)->_Mynextiter;
            } else { 
                const auto _Extracted   = *_Pnext;
                *_Pnext                 = (*_Pnext)->_Mynextiter;
                _Extracted->_Myproxy    = _Myproxy;
                _Extracted->_Mynextiter = _Myproxy->_Myfirstiter;
                _Myproxy->_Myfirstiter  = _Extracted;
            }
        }
    }
#line 1463 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

    void _Splice_after(_Nodeptr _Where, forward_list& _Right, _Nodeptr _Prev) noexcept {
        


#line 1469 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        if constexpr (!_Alnode_traits::is_always_equal::value) {
            do { if (_Getal() == _Right._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1470, 0, "%s", "forward_list containers incompatible for splice_after")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list containers incompatible for splice_after\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1470, 0); } while (false); } ; } while (false);
        }
#line 1473 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"


        if (this != ::std:: addressof(_Right)) {
            _Lockit _Lock(3);
            _Transfer_ownership(_Right, _Prev->_Next);
        }
#line 1480 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
        


#line 1498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
        if constexpr (!_Alnode_traits::is_always_equal::value) {
            do { if (_Getal() == _Right._Getal()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1499, 0, "%s", "forward_list containers incompatible for splice_after")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"forward_list containers incompatible for splice_after\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list", 1499, 0); } while (false); } ; } while (false);
        }
#line 1502 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"

        if (_First == _Last) {
            return;
        }


        if (this != ::std:: addressof(_Right)) { 
            _Lockit _Lock(3);
            _Unchecked_const_iterator _Next = _First;
            while (++_Next != _Last) { 
                _Transfer_ownership(_Right, _Next._Ptr);
            }
        }
#line 1516 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(static_cast<_Rebind_alloc_t<_Alnode, _Container_proxy>>(_Getal()));
    }

    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 1560 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"





#line 1566 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1584 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1614 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1626 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"


namespace pmr {
     template <class _Ty>
    using forward_list = ::std:: forward_list<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 1633 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
}


#pragma warning(pop)
#pragma pack(pop)
#line 1639 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#line 1640 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\forward_list"
#pragma external_header(pop)
#line 26 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\istream"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"





#pragma once









#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\streambuf"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"





#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\share.h"







#pragma once




#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\share.h"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"





#pragma once






#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"





#pragma once












#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {






 template <class _ExPo, class _FwdIt, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt uninitialized_copy(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _NoThrowFwdIt _Dest) noexcept
 {
    
    
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_NoThrowFwdIt> && is_lvalue_reference_v<_Iter_ref_t<_NoThrowFwdIt>>, "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " "to lvalues.");

    return ::std:: uninitialized_copy(_First, _Last, _Dest);
}
#line 50 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"


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(_Unwrap_iter<_Se>(::std:: move(_First1)),
                _Unwrap_sent<_It>(::std:: move(_Last1)), _Unwrap_iter<_OSe>(::std:: move(_First2)),
                _Unwrap_sent<_Out>(::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(
                _Unwrap_range_iter<_Rng1>(::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 {
                    do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory", 110, 0, "%s", "Tried to uninitialized_copy two ranges with unreachable sentinels")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Tried to uninitialized_copy two ranges with unreachable sentinels\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory", 110, 0); } while (false); } ; } while (false);
                }
            } 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 127 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_n(_UFirst, static_cast<size_t>(_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;
}


 template <class _ExPo, class _FwdIt, class _Diff, class _NoThrowFwdIt,
    _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt uninitialized_copy_n(_ExPo&&, const _FwdIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) noexcept
 {
    
    
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_NoThrowFwdIt> && is_lvalue_reference_v<_Iter_ref_t<_NoThrowFwdIt>>, "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " "to lvalues.");

    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    return ::std:: uninitialized_copy_n(_First, _Count, _Dest);
}
#line 168 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"


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 = _Unwrap_iter<_OSe>(::std:: move(_First2));
            auto _OLast  = _Unwrap_sent<_Out>(::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, ::std:: move(_IFirst));
            _Seek_wrapped(_First2, ::std:: move(_OFirst));
            return {::std:: move(_First1), ::std:: move(_First2)};
        }
    };

     inline constexpr _Uninitialized_copy_n_fn uninitialized_copy_n{_Not_quite_object::_Construct_tag{}};
} 
#line 221 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, ::std:: _Uninitialized_move_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}

 template <class _ExPo, class _FwdIt, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt uninitialized_move(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _NoThrowFwdIt _Dest) noexcept
 {
    
    
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_NoThrowFwdIt> && is_lvalue_reference_v<_Iter_ref_t<_NoThrowFwdIt>>, "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " "to lvalues.");

    return ::std:: uninitialized_move(_First, _Last, _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(_Unwrap_iter<_Se>(::std:: move(_First1)),
                _Unwrap_sent<_It>(::std:: move(_Last1)), _Unwrap_iter<_OSe>(::std:: move(_First2)),
                _Unwrap_sent<_Out>(::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(
                _Unwrap_range_iter<_Rng1>(::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 282 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_n(_UFirst, static_cast<size_t>(_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};
}

 template <class _ExPo, class _FwdIt, class _Diff, class _NoThrowFwdIt,
    _Enable_if_execution_policy_t<_ExPo> = 0>
pair<_FwdIt, _NoThrowFwdIt> uninitialized_move_n(
    _ExPo&&, const _FwdIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) noexcept  {
    
    
    static_assert(_Is_ranges_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_ranges_fwd_iter_v<_NoThrowFwdIt> && is_lvalue_reference_v<_Iter_ref_t<_NoThrowFwdIt>>, "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " "to lvalues.");

    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    return ::std:: uninitialized_move_n(_First, _Count, _Dest);
}

 template <class _ExPo, class _NoThrowFwdIt, class _Tval, _Enable_if_execution_policy_t<_ExPo> = 0>
void uninitialized_fill(_ExPo&&, const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) noexcept
 {
    
    
    static_assert(_Is_ranges_fwd_iter_v<_NoThrowFwdIt> && is_lvalue_reference_v<_Iter_ref_t<_NoThrowFwdIt>>, "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " "to lvalues.");

    ::std:: uninitialized_fill(_First, _Last, _Val);
}
#line 334 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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      = _Unwrap_iter<_OSe>(::std:: move(_First2));
            const auto _OLast = _Unwrap_sent<_Out>(::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, ::std:: move(_IFirst));
            _Seek_wrapped(_First2, ::std:: move(_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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 441 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}


 template <class _ExPo, class _NoThrowFwdIt, class _Diff, class _Tval,
    _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt uninitialized_fill_n(
    _ExPo&&, const _NoThrowFwdIt _First, const _Diff _Count_raw, const _Tval& _Val) noexcept
 {
    
    
    static_assert(_Is_ranges_fwd_iter_v<_NoThrowFwdIt> && is_lvalue_reference_v<_Iter_ref_t<_NoThrowFwdIt>>, "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " "to lvalues.");

    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    return ::std:: uninitialized_fill_n(_First, _Count, _Val);
}
#line 490 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"


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(_Ty* _Ptr, _Types&&... _Args) {
                ::new (static_cast<void*>(_Ptr)) _Ty(static_cast<_Types&&>(_Args)...); 
            }
        constexpr _Ty* operator()(_Ty* _Location, _Types&&... _Args) const
            noexcept(noexcept(::new (static_cast<void*>(_Location))
                    _Ty(::std:: forward<_Types>(_Args)...)))  {
            
            [[msvc::constexpr]] return ::new (static_cast<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 571 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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));
}

 template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void destroy(_ExPo&& _Exec, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept; 


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(_Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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(_Unwrap_range_iter<_Rng>(::std:: move(_First)), _Uend(_Range)));
            return _First;
        }
    };

     inline constexpr _Destroy_fn destroy{_Not_quite_object::_Construct_tag{}};
} 
#line 625 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}

 template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt destroy_n(_ExPo&& _Exec, _NoThrowFwdIt _First, _Diff _Count_raw) noexcept; 


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 683 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();
    }
}

 template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void uninitialized_default_construct(_ExPo&& _Exec, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept; 


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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 755 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}

 template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt uninitialized_default_construct_n(
    _ExPo&& _Exec, _NoThrowFwdIt _First, _Diff _Count_raw) noexcept; 


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 816 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();
    }
}

 template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void uninitialized_value_construct(_ExPo&& _Exec, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept; 


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(
                _Unwrap_iter<_Se>(::std:: move(_First)), _Unwrap_sent<_It>(::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 889 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}

 template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> = 0>
_NoThrowFwdIt uninitialized_value_construct_n(
    _ExPo&& _Exec, _NoThrowFwdIt _First, _Diff _Count_raw) noexcept; 


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 939 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"
#line 940 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"


template <class _PtrTy>
[[nodiscard]] void* _Voidify_unfancy(_PtrTy _Ptr) noexcept {
    if constexpr (is_pointer_v<_PtrTy>) {
        return _Ptr;
    } else {
        return ::std:: addressof(*_Ptr);
    }
}
#line 951 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

















































#line 1001 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"












































































































#line 1110 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1160 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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; 

    void* _Get_deleter(const type_info& _Typeid) const noexcept override {

        if (_Typeid == typeid(_Dx)) {
            return const_cast<_Dx*>(::std:: addressof(_Mypair._Get_first()));
        }


#line 1235 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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; 

    void* _Get_deleter(const type_info& _Typeid) const noexcept override {

        if (_Typeid == typeid(_Dx)) {
            return const_cast<_Dx*>(::std:: addressof(_Mypair._Get_first()));
        }


#line 1269 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1483 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1568 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1661 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    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, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    shared_ptr& operator=(shared_ptr<_Ty2>&& _Right) noexcept { 
        shared_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }







#line 1715 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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& 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,
        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>
    void reset(_Ux* _Px) { 
        shared_ptr(_Px).swap(*this);
    }

    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>
    void reset(_Ux* _Px, _Dx _Dt) { 
        shared_ptr(_Px, _Dt).swap(*this);
    }

    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>
    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 1780 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1848 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1873 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1910 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1977 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2061 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2076 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"


struct _For_overwrite_tag {
    explicit _For_overwrite_tag() = default;
};
#line 2082 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>> && ...)) {
            ::std:: _Default_construct_in_place(_Storage._Value);
            ((void) _Args, ...);
        } else
#line 2094 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"
        {
            ::std:: _Construct_in_place(_Storage._Value, ::std:: forward<_Types>(_Args)...);
        }
    }

    ~_Ref_count_obj2() noexcept override { 
        

        
        
        
    }

    union {
        _Wrap<remove_cv_t<_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 > 16ull) {
        return static_cast<_Refc*>(::operator new(_Bytes, align_val_t{_Align}));
    } else
#line 2172 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 > 16ull) {
        ::operator delete(static_cast<void*>(_Ptr), align_val_t{_Align});
    } else
#line 2185 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) { 
        ::std:: _Construct_in_place(*_Last, ::std:: forward<_Types>(_Vals)...);
        ++_Last;
    }

    void _Emplace_back_for_overwrite() {
        ::std:: _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_n(_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<remove_cv_t<_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<remove_cv_t<_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<remove_cv_t<_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 2465 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

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 2484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_n(_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 2761 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

 template <class _Ty, class... _Types>
[[nodiscard("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]]

    enable_if_t<!is_array_v<_Ty>, shared_ptr<_Ty>>


#line 2769 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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 2856 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

 template <class _Ty, class _Alloc, class... _Types>
[[nodiscard("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]]

    enable_if_t<!is_array_v<_Ty>, shared_ptr<_Ty>>


#line 2864 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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 (::std:: _Voidify_unfancy(_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, ::std:: _Unfancy(_Constructor._Release()));
    return _Ret;
}

 template <class _Ty, class _Alloc>
[[nodiscard("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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 (::std:: _Voidify_unfancy(_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, ::std:: _Unfancy(_Constructor._Release()));
    return _Ret;
}

 template <class _Ty, class _Alloc>
[[nodiscard("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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 (::std:: _Voidify_unfancy(_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, ::std:: _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();
        ::std:: _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, ::std:: _Unfancy(_Constructor._Release()));
    }

    return _Ret;
}

 template <class _Ty, class _Alloc>
[[nodiscard("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] 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 2996 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3014 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3033 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3052 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    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, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    weak_ptr& operator=(weak_ptr<_Ty2>&& _Right) noexcept {
        weak_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    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 3115 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    inline default_delete(const default_delete<_Ty2>&) noexcept {}

    inline 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>
    inline default_delete(const default_delete<_Uty[]>&) noexcept {}

    template <class _Uty, enable_if_t<is_convertible_v<_Uty (*)[], _Ty (*)[]>, int> = 0>
    inline 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{}) {}

    inline unique_ptr& operator=(nullptr_t) noexcept {
        reset();
        return *this;
    }

    
    
    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
    inline 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>
    inline 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>
    inline 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>
    inline 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>
    inline unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Dx2>(_Right.get_deleter()), _Right.release()) {}





#line 3255 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
    inline 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>
    inline unique_ptr& operator=(unique_ptr&& _Right) noexcept {
        reset(_Right.release());
        _Mypair._Get_first() = ::std:: forward<_Dx>(_Right._Mypair._Get_first());
        return *this;
    }

    inline void swap(unique_ptr& _Right) noexcept {
        using ::std:: swap;
        swap(_Mypair._Myval2, _Right._Mypair._Myval2); 
        swap(_Mypair._Get_first(), _Right._Mypair._Get_first()); 
    }

    inline ~unique_ptr() noexcept {
        if (_Mypair._Myval2) {
            _Mypair._Get_first()(_Mypair._Myval2);
        }
    }

    [[nodiscard]] inline _Dx& get_deleter() noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] inline const _Dx& get_deleter() const noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] inline add_lvalue_reference_t<_Ty> operator*() const noexcept(noexcept(*::std:: declval<pointer>())) {
        return *_Mypair._Myval2;
    }

    [[nodiscard]] inline pointer operator->() const noexcept {
        return _Mypair._Myval2;
    }

    [[nodiscard]] inline pointer get() const noexcept {
        return _Mypair._Myval2;
    }

    inline explicit operator bool() const noexcept {
        return static_cast<bool>(_Mypair._Myval2);
    }

    inline pointer release() noexcept {
        return ::std:: exchange(_Mypair._Myval2, nullptr);
    }

    inline 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 (*)[]>),
            int>;

    template <class _Uty, class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0, _Enable_ctor_reset<_Uty> = 0>
    inline 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,
        _Enable_ctor_reset<_Uty> = 0>
    inline 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,
        _Enable_ctor_reset<_Uty>                                                                    = 0>
    inline 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>
    inline 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>
    inline 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>,
        int>;

    template <class _Uty, class _Ex,
        _Enable_conversion<_Uty, _Ex, conditional_t<is_reference_v<_Dx>, is_same<_Ex, _Dx>, is_convertible<_Ex, _Dx>>> =
            0>
    inline 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, _Enable_conversion<_Uty, _Ex, is_assignable<_Dx&, _Ex>> = 0>
    inline 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{}) {}

    inline unique_ptr& operator=(nullptr_t) noexcept {
        reset();
        return *this;
    }

    inline void reset(nullptr_t = nullptr) noexcept {
        reset(pointer());
    }

    inline void swap(unique_ptr& _Right) noexcept {
        using ::std:: swap;
        swap(_Mypair._Myval2, _Right._Mypair._Myval2); 
        swap(_Mypair._Get_first(), _Right._Mypair._Get_first()); 
    }

    inline ~unique_ptr() noexcept {
        if (_Mypair._Myval2) {
            _Mypair._Get_first()(_Mypair._Myval2);
        }
    }

    [[nodiscard]] inline _Dx& get_deleter() noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] inline const _Dx& get_deleter() const noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] inline _Ty& operator[](size_t _Idx) const noexcept  {
        return _Mypair._Myval2[_Idx];
    }

    [[nodiscard]] inline pointer get() const noexcept {
        return _Mypair._Myval2;
    }

    inline explicit operator bool() const noexcept {
        return static_cast<bool>(_Mypair._Myval2);
    }

    inline pointer release() noexcept {
        return ::std:: exchange(_Mypair._Myval2, nullptr);
    }

    template <class _Uty, _Enable_ctor_reset<_Uty, false_type> = 0>
    inline 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] inline 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] inline 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] inline 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("This function constructs an object wrapped by a smart pointer and has no other effects; " "it is not useful to call this function and discard the return value.")]] inline 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 3495 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

 template <class _Ty, class _Dx, enable_if_t<_Is_swappable<_Dx>::value, int> = 0>
inline 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]] inline bool operator==(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    return _Left.get() == _Right.get();
}






#line 3512 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 3548 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

 template <class _Ty, class _Dx>
[[nodiscard]] inline bool operator==(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) noexcept {
    return !_Left;
}
















#line 3570 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

 template <class _Ty, class _Dx>
[[nodiscard]] inline 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]] inline 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]] inline bool operator>=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    return !(_Left < _Right);
}

 template <class _Ty, class _Dx>
[[nodiscard]] inline bool operator>=(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
    return !(_Left < _Right);
}

 template <class _Ty, class _Dx>
[[nodiscard]] inline bool operator>(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    return _Right < _Left;
}

 template <class _Ty, class _Dx>
[[nodiscard]] inline bool operator>(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
    return _Right < _Left;
}

 template <class _Ty, class _Dx>
[[nodiscard]] inline bool operator<=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    return !(_Right < _Left);
}

 template <class _Ty, class _Dx>
[[nodiscard]] inline 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]] inline 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 3621 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
}


 enum class pointer_safety { relaxed, preferred, strict };

 inline void declare_reachable(void*) {}

 template <class _Ty>
_Ty* undeclare_reachable(_Ty* _Ptr) {
    return _Ptr;
}

 inline void declare_no_pointers(char*, size_t) {}

 inline void undeclare_no_pointers(char*, size_t) {}

 inline pointer_safety get_pointer_safety() noexcept {
    return pointer_safety::relaxed;
}
#line 3654 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

 template <class _Ty = void>
struct owner_less; 

template <class _Ty>
struct owner_less<shared_ptr<_Ty>> {
    using _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 suppress this warning.")]]  = shared_ptr<_Ty>;
    using _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 suppress this warning.")]] = shared_ptr<_Ty>;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[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>> {
    using _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 suppress this warning.")]]  = weak_ptr<_Ty>;
    using _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 suppress this warning.")]] = weak_ptr<_Ty>;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]          = bool;

    [[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>> {
    using _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 suppress this warning.")]] = shared_ptr<_Ty>;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[nodiscard]] size_t operator()(const shared_ptr<_Ty>& _Keyval) const noexcept {
        return hash<typename shared_ptr<_Ty>::element_type*>()(_Keyval.get());
    }
};


 template <size_t _Nx, class _Ty>
[[nodiscard("'std::assume_aligned' has a potential effect on the return value (not on the passed argument). " "It is not useful to call 'std::assume_aligned' and discard the return value.")]] 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 3751 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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 suppress 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(remove_extent_t<_Ty>* const _Px, _Ref_count_base* const _Ref) noexcept
        : _Ptr(_Px), _Repptr(_Ref) {}

    void _Wait(remove_extent_t<_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<remove_extent_t<_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();
        remove_extent_t<_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(static_cast<unsigned int>(_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(static_cast<unsigned int>(_Order));
        auto _Rep = this->_Repptr._Lock_and_load();
        if (this->_Ptr.load(memory_order_relaxed) == _Expected._Ptr && _Rep == _Expected._Rep) {
            remove_extent_t<_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));
    }

    void operator=(nullptr_t) noexcept {
        store(nullptr);
    }

    ~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();
        remove_extent_t<_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(static_cast<unsigned int>(_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(static_cast<unsigned int>(_Order));
        auto _Rep = this->_Repptr._Lock_and_load();
        if (this->_Ptr.load(memory_order_relaxed) == _Expected._Ptr && _Rep == _Expected._Rep) {
            remove_extent_t<_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 4130 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"












































































































































































































#line 4335 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"















#line 4351 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"

}






#pragma warning(pop)
#pragma pack(pop)
#line 4362 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"
#line 4363 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\memory"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
extern "C++" class __declspec(dllimport) _Facet_base { 
public:
    virtual  ~_Facet_base() noexcept {} 

    
    virtual void  _Incref() noexcept = 0;

    
    virtual _Facet_base*  _Decref() noexcept = 0;
};




#line 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xfacet"
extern "C++" void __cdecl _Facet_Register(_Facet_base*);
#line 41 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xfacet"
}


#pragma warning(pop)
#pragma pack(pop)
#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xfacet"
#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xfacet"
#pragma external_header(pop)
#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_xlocinfo_types.hpp"
#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_xlocinfo_types.hpp"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\clocale"





#pragma once





#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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;























    __declspec(dllimport) void __cdecl _lock_locales(void);
    __declspec(dllimport) void __cdecl _unlock_locales(void);

    
    __declspec(dllimport) int __cdecl _configthreadlocale(
          int _Flag
        );

        
    __declspec(dllimport) char* __cdecl setlocale(
                int         _Category,
          char const* _Locale
        );

    
    __declspec(dllimport) struct lconv* __cdecl localeconv(void);

    
    __declspec(dllimport) _locale_t __cdecl _get_current_locale(void);

    
    __declspec(dllimport) _locale_t __cdecl _create_locale(
            int         _Category,
          char const* _Locale
        );

    __declspec(dllimport) void __cdecl _free_locale(
          _locale_t _Locale
        );

    
        
    __declspec(dllimport) wchar_t* __cdecl _wsetlocale(
                int            _Category,
          wchar_t const* _Locale
        );

    
    __declspec(dllimport) _locale_t __cdecl _wcreate_locale(
            int            _Category,
          wchar_t const* _Locale
        );



    __declspec(dllimport) wchar_t**    __cdecl ___lc_locale_name_func(void);
    __declspec(dllimport) unsigned int __cdecl ___lc_codepage_func   (void);
    __declspec(dllimport) unsigned int __cdecl ___lc_collate_cp_func (void);




    
     
     
    __declspec(dllimport) char*    __cdecl _Getdays(void);

     
     
    __declspec(dllimport) char*    __cdecl _Getmonths(void);

    __declspec(dllimport) void*    __cdecl _Gettnames(void);

     
     
    __declspec(dllimport) wchar_t* __cdecl _W_Getdays(void);

     
     
    __declspec(dllimport) wchar_t* __cdecl _W_Getmonths(void);

    __declspec(dllimport) void*    __cdecl _W_Gettnames(void);

     
    __declspec(dllimport) size_t __cdecl _Strftime(
          char*           _Buffer,
                              size_t           _Max_size,
                            char const*      _Format,
                              struct tm const* _Timeptr,
                          void*            _Lc_time_arg);

     
    __declspec(dllimport) 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.22621.0\\ucrt\\locale.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\locale.h"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\clocale"
#line 34 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\clocale"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"

 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" {
    __declspec(dllimport) char* __cdecl _Getdays();

    __declspec(dllimport) char* __cdecl _Getmonths();

__declspec(dllimport) void* __cdecl _Gettnames();

  __declspec(dllimport) size_t __cdecl _Strftime(
      char*,   size_t _Maxsize,   const char*,   const tm*,   void*);

    __declspec(dllimport) wchar_t* __cdecl _W_Getdays();

    __declspec(dllimport) wchar_t* __cdecl _W_Getmonths();

__declspec(dllimport) void* __cdecl _W_Gettnames();

  __declspec(dllimport) size_t __cdecl _Wcsftime(
      wchar_t*,   size_t _Maxsize,   const wchar_t*,   const tm*,   void*);
}

namespace std {
extern "C++" class __declspec(dllimport) _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; 
};

extern "C++" template <class _Elem>
class __declspec(dllimport) _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_dbg(_Count, 2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo", 165));


#line 169 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_dbg(_Myptr, 2);


#line 207 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"
        }

        _Myptr = nullptr;
    }

    _Elem* _Myptr; 
    _Elem _Nul; 
};

extern "C++" class __declspec(dllimport) _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 232 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"
    {
        if (_Pch) {
            _Locinfo_ctor(this, _Pch);
            return;
        }

        _Xruntime_error("bad locale name");
    }

     _Locinfo(int _Cat, const char* _Pch)

        : _Lock(0)
#line 245 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 378 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 444 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"
#line 445 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocinfo"
#pragma external_header(pop)
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

extern "C++" struct __declspec(dllimport) _Crt_new_delete { 

    void* __cdecl operator new(size_t _Size) { 
        void* _Ptr = operator new(_Size, nothrow);
        if (!_Ptr) {
            _Xbad_alloc();
        }

        return _Ptr;
    }

    void* __cdecl operator new(size_t _Size, const nothrow_t&) noexcept { 
        return _malloc_dbg(_Size > 0 ? _Size : 1, 2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 71);
    }

    void __cdecl operator delete(void* _Ptr) noexcept { 
        :: free(_Ptr);
    }

    void __cdecl operator delete(void* _Ptr, const nothrow_t&) noexcept { 
        operator delete(_Ptr);
    }

    void* __cdecl operator new(size_t, void* _Ptr) noexcept { 
        return _Ptr;
    }

    void __cdecl operator delete(void*, void*) noexcept {} 
#line 88 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
};

 extern "C++" class locale : public _Locbase<int>, public _Crt_new_delete {
public:
    using category = int;

    class __declspec(dllimport) 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;
    };

    struct _Facet_guard;

    class __declspec(dllimport) facet : public _Facet_base, public _Crt_new_delete {
        
    private:
        friend _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) noexcept 
            : _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 __declspec(dllimport) _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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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    = "*";
        }
    }

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

    
    
    
    
    
    
    locale(_Uninitialized) {} 
#pragma warning(pop)

    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) { 
            do { if ((_Cat & all) == _Cat) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 283, 0, "%s", "the bitmask value specifying category must be valid")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"the bitmask value specifying category must be valid\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 283, 0); } while (false); } ; } while (false);
            _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) {
        do { if ((_Cat & all) == _Cat) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 298, 0, "%s", "the bitmask value specifying category must be valid")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"the bitmask value specifying category must be valid\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 298, 0); } while (false); } ; } while (false);
        
        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 357 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 noexcept {
        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 noexcept  { 
        return _Ptr == _Loc._Ptr || (:: strcmp(_C_str(), "*") != 0 && :: strcmp(_C_str(), _Loc._C_str()) == 0);
    }





#line 405 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 451 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
        } else { 
            auto _Pfmod = const_cast<locale::facet*>(_Psave);
            unique_ptr<_Facet_base> _Psave_guard(static_cast<_Facet_base*>(_Pfmod));



#line 458 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
            _Facet_Register(_Pfmod);
#line 460 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 524 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_dbg(_Count, sizeof(_Elem), 2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 530));

    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_dbg(_Wchars, sizeof(wchar_t), 2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 563));

    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_dbg(_Wchars, sizeof(wchar_t), 2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale", 604));

    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 622 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"

 extern "C++" class __declspec(dllimport) codecvt_base 
    : public locale::facet 
{
public:
    enum { 
        ok,
        partial,
        error,
        noconv
    };
    using result = int;

     codecvt_base(size_t _Refs = 0) noexcept 
        : 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 _Ty>
inline constexpr bool _Is_one_byte_char_like_v = _Is_any_of_v<remove_cv_t<_Ty>, signed char, unsigned char,

    byte,
#line 675 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"

    char8_t,
#line 678 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
    char>;

template <class _Elem, class _Byte>
inline constexpr bool _Is_codecvt_do_always_noconv_v =
    is_same_v<_Byte, _Elem> || (_Is_one_byte_char_like_v<_Byte> && _Is_one_byte_char_like_v<_Elem>);

 extern "C++" 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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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_codecvt_do_always_noconv_v<_Elem, _Byte>;
    }

    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_codecvt_do_always_noconv_v<_Elem, _Byte>) {
            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_codecvt_do_always_noconv_v<_Elem, _Byte>) {
            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 };

extern "C++" template <>
class __declspec(dllimport) [[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 suppress 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; 
};

extern "C++" template <>
class __declspec(dllimport) [[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 suppress 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;
    }
};

extern "C++" 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);
    }

    __declspec(dllimport) 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; 
    }
};

extern "C++" 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);
    }

    __declspec(dllimport) 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 1937 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"

extern "C++" template <>
class __declspec(dllimport) 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;
                [[fallthrough]];

            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; 
};


extern "C++" template <>
class __declspec(dllimport) 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;
                [[fallthrough]];

            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 2337 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2346 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
                          codecvt_byname<char, char, mbstate_t>, codecvt_byname<wchar_t, char, mbstate_t>>,
        "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 {}
};











 extern "C++" struct __declspec(dllimport) 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) noexcept 
        : locale::facet(_Refs) {}

     ~ctype_base() noexcept override {}
};











 extern "C++" template <class _Elem>
class ctype : public ctype_base { 
public:
    
    static_assert(!0 || _Always_false<_Elem>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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;





extern "C++" template <>
class __declspec(dllimport) 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; 
};

extern "C++" template <>
class __declspec(dllimport) 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; 
};


extern "C++" template <>
class __declspec(dllimport) 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 3234 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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; 
}



template class __declspec(dllimport) codecvt<char, char, mbstate_t>;
#line 3303 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
#line 3304 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
}


#pragma warning(pop)
#pragma pack(pop)
#line 3310 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
#line 3311 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocale"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 int skipws     = 0x0001;
    static constexpr int unitbuf    = 0x0002;
    static constexpr int uppercase  = 0x0004;
    static constexpr int showbase   = 0x0008;
    static constexpr int showpoint  = 0x0010;
    static constexpr int showpos    = 0x0020;
    static constexpr int left       = 0x0040;
    static constexpr int right      = 0x0080;
    static constexpr int internal   = 0x0100;
    static constexpr int dec        = 0x0200;
    static constexpr int oct        = 0x0400;
    static constexpr int hex        = 0x0800;
    static constexpr int scientific = 0x1000;
    static constexpr int fixed      = 0x2000;

    static constexpr int hexfloat = 0x3000; 

    static constexpr int boolalpha   = 0x4000;
    static constexpr int _Stdio      = 0x8000;
    static constexpr int adjustfield = 0x01C0; 
    static constexpr int basefield   = 0x0E00; 
    static constexpr int floatfield  = 0x3000; 

    enum _Iostate { 
        _Statmask = 0x17
    };

    static constexpr int goodbit = 0x0;
    static constexpr int eofbit  = 0x1;
    static constexpr int failbit = 0x2;
    static constexpr int badbit  = 0x4;

    enum _Openmode { 
        _Openmask = 0xff
    };

    static constexpr int in         = 0x01;
    static constexpr int out        = 0x02;
    static constexpr int ate        = 0x04;
    static constexpr int app        = 0x08;
    static constexpr int trunc      = 0x10;
    static constexpr int _Nocreate  = 0x40;
    static constexpr int _Noreplace = 0x80;
    static constexpr int binary     = 0x20;


#line 79 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

    enum _Seekdir { 
        _Seekbeg,
        _Seekcur,
        _Seekend
    };

    static constexpr int beg = _Seekbeg;
    static constexpr int cur = _Seekcur;
    static constexpr int end = _Seekend;

    enum { 
        _Openprot = 0x40
    };

    static constexpr int _Default_open_prot = 0x40; 
};

 extern "C++" class __declspec(dllimport) ios_base : public _Iosb<int> { 
public:
    using fmtflags = int;
    using iostate  = int;
    using openmode = int;
    using seekdir  = int;




#line 108 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

    enum event { 
        erase_event,
        imbue_event,
        copyfmt_event
    };

    using event_callback = void(__cdecl*)(event, ios_base&, int);





#line 122 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

    class failure : public system_error { 
    public:
        explicit failure(const string& _Message, const error_code& _Errcode = ::std:: make_error_code(io_errc::stream))
            : system_error(_Errcode, _Message) {} 

        explicit failure(const char* _Message, const error_code& _Errcode = ::std:: make_error_code(io_errc::stream))
            : system_error(_Errcode, _Message) {} 






#line 137 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"
    };

    class __declspec(dllimport) 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 noexcept  {
        return !fail();
    }

    [[nodiscard]] bool  operator!() const noexcept  {
        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 197 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

    [[nodiscard]] iostate  rdstate() const noexcept  {
        return _Mystate;
    }

    void  setstate(
        iostate _State, bool _Exreraise) { 
        clear(rdstate() | _State, _Exreraise);
    }

    void  setstate(iostate _State) { 
        clear(rdstate() | _State, false);
    }





#line 216 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

    [[nodiscard]] bool  good() const noexcept  {
        return rdstate() == ios_base::goodbit;
    }

    [[nodiscard]] bool  eof() const noexcept  {
        return rdstate() & ios_base::eofbit;
    }

    [[nodiscard]] bool  fail() const noexcept  {
        return rdstate() & (ios_base::badbit | ios_base::failbit);
    }

    [[nodiscard]] bool  bad() const noexcept  {
        return rdstate() & ios_base::badbit;
    }

    [[nodiscard]] iostate  exceptions() const noexcept  {
        return _Except;
    }

    void  exceptions(iostate _Newexcept) { 
        _Except = _Newexcept & _Statmask;
        clear(rdstate());
    }





#line 247 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"

    [[nodiscard]] fmtflags  flags() const noexcept  {
        return _Fmtfl;
    }

    fmtflags  flags(fmtflags _Newfmtflags) noexcept  {
        
        const fmtflags _Oldfmtflags = _Fmtfl;
        _Fmtfl                      = _Newfmtflags & _Fmtmask;
        return _Oldfmtflags;
    }

    fmtflags  setf(fmtflags _Newfmtflags) noexcept  {
        
        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
        _Fmtfl |= _Newfmtflags & _Fmtmask;
        return _Oldfmtflags;
    }

    fmtflags  setf(fmtflags _Newfmtflags, fmtflags _Mask) noexcept  {
        
        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
        _Fmtfl                                = (_Oldfmtflags & ~_Mask) | (_Newfmtflags & _Mask & _Fmtmask);
        return _Oldfmtflags;
    }

    void  unsetf(fmtflags _Mask) noexcept  {
        
        _Fmtfl &= ~_Mask;
    }

    [[nodiscard]] streamsize  precision() const noexcept  {
        return _Prec;
    }

    streamsize  precision(streamsize _Newprecision) noexcept  {
        
        const streamsize _Oldprecision = _Prec;
        _Prec                          = _Newprecision;
        return _Oldprecision;
    }

    [[nodiscard]] streamsize  width() const noexcept  {
        return _Wide;
    }

    streamsize  width(streamsize _Newwidth) noexcept  {
        
        const streamsize _Oldwidth = _Wide;
        _Wide                      = _Newwidth;
        return _Oldwidth;
    }

    [[nodiscard]] locale  getloc() const noexcept  { 
        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) noexcept  {
        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 495 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"
#line 496 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xiosbase"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
 extern "C++" template <class _Elem, class _Traits>
class basic_streambuf { 
protected:
     basic_streambuf() : _Plocale(new locale) {
        _Init();
    }

     basic_streambuf(_Uninitialized) noexcept {}

     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) noexcept  {
        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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\streambuf"

    pos_type  pubseekpos(pos_type _Pos,
        ios_base::openmode _Mode = ios_base::in | ios_base::out) { 
        return seekpos(_Pos, _Mode);
    }






#line 99 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 noexcept  { 
        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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 noexcept  {
        return *_IGfirst;
    }

    _Elem*  gptr() const noexcept  {
        return *_IGnext;
    }

    _Elem*  pbase() const noexcept  {
        return *_IPfirst;
    }

    _Elem*  pptr() const noexcept  {
        return *_IPnext;
    }

    _Elem*  egptr() const noexcept  {
        return *_IGnext + *_IGcount;
    }

    void  gbump(int _Off) noexcept  {
        
        *_IGcount -= _Off;
        *_IGnext += _Off;
    }

    void  setg(_Elem* _First, _Elem* _Next, _Elem* _Last) noexcept  {
        
        *_IGfirst = _First;
        *_IGnext  = _Next;
        *_IGcount = static_cast<int>(_Last - _Next);
    }

    _Elem*  epptr() const noexcept  {
        return *_IPnext + *_IPcount;
    }

    _Elem*  _Gndec() noexcept { 
        ++*_IGcount;
        return --*_IGnext;
    }

    _Elem*  _Gninc() noexcept { 
        --*_IGcount;
        return (*_IGnext)++;
    }

    _Elem*  _Gnpreinc() noexcept { 
        --*_IGcount;
        return ++(*_IGnext);
    }

    streamsize  _Gnavail() const noexcept { 
        return *_IGnext ? *_IGcount : 0;
    }

    void  pbump(int _Off) noexcept  {
        
        *_IPcount -= _Off;
        *_IPnext += _Off;
    }

    void  setp(_Elem* _First, _Elem* _Last) noexcept  {
        
        *_IPfirst = _First;
        *_IPnext  = _First;
        *_IPcount = static_cast<int>(_Last - _First);
    }

    void  setp(_Elem* _First, _Elem* _Next, _Elem* _Last) noexcept  {
        
        *_IPfirst = _First;
        *_IPnext  = _Next;
        *_IPcount = static_cast<int>(_Last - _Next);
    }

    _Elem*  _Pninc() noexcept { 
        --*_IPcount;
        return (*_IPnext)++;
    }

    streamsize  _Pnavail() const noexcept { 
        return *_IPnext ? *_IPcount : 0;
    }

    void  _Init() noexcept { 
        _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) noexcept {
        
        _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{}; 
};




template class __declspec(dllimport) basic_streambuf<char, char_traits<char>>;
template class __declspec(dllimport) basic_streambuf<wchar_t, char_traits<wchar_t>>;
#line 408 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\streambuf"




#line 413 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\streambuf"
}



#pragma warning(pop)
#pragma pack(pop)
#line 420 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\streambuf"
#line 421 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\streambuf"
#pragma external_header(pop)
#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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" {

 long __cdecl _Stolx(const char*,     char**, int, int*);
 unsigned long __cdecl _Stoulx(
    const char*,     char**, int, int*);
 long long __cdecl _Stollx(
    const char*,     char**, int, int*);
 unsigned long long __cdecl _Stoullx(
    const char*,     char**, int, int*);

}

namespace std {

inline constexpr size_t _Max_int_dig = 32; 

inline double _Stodx_v3(const char* _Str, char** _Endptr, int* _Perr) noexcept { 
    int& _Errno_ref = (*_errno()); 
    const int _Orig = _Errno_ref;

    _Errno_ref  = 0;
    double _Val = :: strtod(_Str, _Endptr);
    *_Perr      = _Errno_ref;
    _Errno_ref  = _Orig;

    return _Val;
}

inline float _Stofx_v3(const char* _Str, char** _Endptr, int* _Perr) noexcept { 
    int& _Errno_ref = (*_errno()); 
    const int _Orig = _Errno_ref;

    _Errno_ref = 0;
    float _Val = :: strtof(_Str, _Endptr);
    *_Perr     = _Errno_ref;
    _Errno_ref = _Orig;

    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>(::std:: _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_dbg(_Count, sizeof(wchar_t), 2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum", 75));

    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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
    using char_type   = _Elem;

     __declspec(dllimport) 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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 247 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"

struct _Num_get_parse_result {
    
    
    
    int8_t _Base;
    bool _Bad_grouping;
};

 extern "C++" 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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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[_Max_int_dig];
            const auto _Parse_result =
                _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
            if (_Parse_result._Base < 0) {
                
                
                _Val   = false;
                _State = ios_base::failbit;
            } else {
                char* _Ep;
                int _Errno;
                const long _Ans = :: _Stolx(_Ac, &_Ep, _Parse_result._Base, &_Errno); 
                if (_Ep == _Ac || _Errno != 0 
                    || _Parse_result._Bad_grouping) { 
                    _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[_Max_int_dig];
        const auto _Parse_result =
            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Parse_result._Base < 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, _Parse_result._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 (_Parse_result._Bad_grouping) { 
                _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 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[_Max_int_dig];
        const auto _Parse_result =
            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Parse_result._Base < 0) { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            char* _Ep;
            int _Errno;
            _Val = :: _Stolx(_Ac, &_Ep, _Parse_result._Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0 
                || _Parse_result._Bad_grouping) { 
                _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[_Max_int_dig];
        const auto _Parse_result =
            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Parse_result._Base < 0) { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            char* _Ep;
            int _Errno;
            _Val = :: _Stoulx(_Ac, &_Ep, _Parse_result._Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0 
                || _Parse_result._Bad_grouping) { 
                _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[_Max_int_dig];
        const auto _Parse_result =
            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Parse_result._Base < 0) { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            char* _Ep;
            int _Errno;
            _Val = :: _Stollx(_Ac, &_Ep, _Parse_result._Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0 
                || _Parse_result._Bad_grouping) { 
                _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[_Max_int_dig];
        const auto _Parse_result =
            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Parse_result._Base < 0) { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            int _Errno;
            char* _Ep;
            _Val = :: _Stoullx(_Ac, &_Ep, _Parse_result._Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0 
                || _Parse_result._Bad_grouping) { 
                _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)];
        const auto _Parse_result =
            _Parse_fp_with_locale(_Ac, 768, _First, _Last, _Iosbase.getloc()); 
        if (_Parse_result._Base == 0) { 
            _State = ios_base::failbit;
            _Val   = 0.0f;
        } else {
            int _Errno;
            char* _Ep;
            _Val = ::std:: _Stofx_v3(_Ac, &_Ep, &_Errno); 
            if (_Ep == _Ac || _Errno != 0 
                || _Parse_result._Bad_grouping) { 
                _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,
        double& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[(8 + 768 + 16)];
        const auto _Parse_result =
            _Parse_fp_with_locale(_Ac, 768, _First, _Last, _Iosbase.getloc()); 
        if (_Parse_result._Base == 0) { 
            _State = ios_base::failbit;
            _Val   = 0.0;
        } else {
            int _Errno;
            char* _Ep;
            _Val = ::std:: _Stodx_v3(_Ac, &_Ep, &_Errno); 
            if (_Ep == _Ac || _Errno != 0 
                || _Parse_result._Bad_grouping) { 
                _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 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[_Max_int_dig];
        const auto _Parse_result =
            _Parse_int_with_locale(_Ac, _First, _Last, ios_base::hex, _Iosbase.getloc()); 
        if (_Parse_result._Base < 0) { 
            _State = ios_base::failbit;
            _Val   = nullptr;
        } else {
            int _Errno;
            char* _Ep;

            _Val = reinterpret_cast<void*>(:: _Stoullx(_Ac, &_Ep, _Parse_result._Base, &_Errno));


#line 642 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"
            if (_Ep == _Ac || _Errno != 0) { 
                _State = ios_base::failbit;
                _Val   = nullptr;
            }

            if (_Parse_result._Bad_grouping) { 
                _State = ios_base::failbit;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

private:
    template <int = 0> 
    static _Num_get_parse_result _Parse_int_with_locale(
        char* const _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield, const locale& _Loc) {
        
        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);

        bool _Bad_grouping = false;

        
        if (_Kseparator != _Elem{}) {
            while (_First != _Last && *_First == _Kseparator) {
                ++_First;
                _Bad_grouping = true;
            }
        }

        char* _Ptr = _Ac;

        if (_First != _Last) {
            if (*_First == _Atoms[_Numget_signoff + 1]) { 
                *_Ptr++ = '+';
                ++_First;
            } else if (*_First == _Atoms[_Numget_signoff]) { 
                *_Ptr++ = '-';
                ++_First;
            }
        }

        
        if (_Kseparator != _Elem{}) {
            while (_First != _Last && *_First == _Kseparator) {
                ++_First;
                _Bad_grouping = true;
            }
        }

        _Basefield &= ios_base::basefield;

        int8_t _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 _Groups_arr_idx = 0;

        for (char* const _Pe = &_Ac[_Max_int_dig - 1]; _First != _Last; ++_First) { 
            size_t _Idx = ::std:: _Find_elem(_Atoms, *_First);
            if (_Idx < _Dlen) { 
                *_Ptr = _Src[_Idx];
                if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe) {
                    ++_Ptr;
                    _Nonzero = true;
                }

                _Seendigit = true;
                if (_Groups[_Groups_arr_idx] != 127) {
                    ++_Groups[_Groups_arr_idx];
                }
            } else if (_Kseparator == _Elem{} || *_First != _Kseparator) {
                break; 
            } else if (_Groups[_Groups_arr_idx] == '\0') {
                _Bad_grouping = true; 
            } else { 
                _Groups.push_back('\0');
                ++_Groups_arr_idx;
            }
        }

        if (_Groups_arr_idx != 0) {
            if (_Groups[_Groups_arr_idx] > '\0') {
                ++_Groups_arr_idx; 
            } else {
                _Bad_grouping = true; 
            }
        }

        
        if (_Kseparator != _Elem{}) {
            while (_First != _Last && *_First == _Kseparator) {
                ++_First;
                _Bad_grouping = true;
            }
        }

        const char* _Grouping_iter      = _Grouping.data();
        const char* const _Grouping_end = _Grouping_iter + _Grouping.size();
        for (char _Current_grouping_count = '\0'; _Seendigit && !_Bad_grouping && _Groups_arr_idx > 0;) {
            if (_Grouping_iter != _Grouping_end) { 
                _Current_grouping_count = *_Grouping_iter; 
                ++_Grouping_iter;
            }

            --_Groups_arr_idx;
            if ((_Current_grouping_count > '\0' && _Current_grouping_count != 127)
                && ((_Groups_arr_idx > 0 && _Groups[_Groups_arr_idx] != _Current_grouping_count)
                    || (_Groups_arr_idx == 0 && _Groups[_Groups_arr_idx] > _Current_grouping_count))) {
                _Bad_grouping = true; 
            }
            
        }

        if (!_Seendigit) {
            return {static_cast<int8_t>(~_Base), false};
        }

        if (!_Nonzero) {
            *_Ptr++ = '0'; 
        }

        *_Ptr = '\0';
        return {_Base, _Bad_grouping};
    }

    template <int = 0> 
    static _Num_get_parse_result _Parse_fp_with_locale(
        char* const _Ac, const int _Max_sig_dig, _InIt& _First, _InIt& _Last, const locale& _Loc) {
        
        char* _Ptr = _Ac;

        constexpr size_t _Offset_dec_digit_end = 10;
        constexpr size_t _Offset_hex_digit_end = 22;
        constexpr size_t _Offset_neg_sign      = 22;
        constexpr size_t _Offset_pos_sign      = 23;
        constexpr size_t _Offset_upper_x       = 24;
        constexpr size_t _Offset_lower_x       = 25;
        constexpr size_t _Offset_upper_p       = 26;
        constexpr size_t _Offset_lower_p       = 27;
        constexpr size_t _Offset_upper_e       = 14;
        constexpr size_t _Offset_lower_e       = 20;
        static constexpr char _Src[]           = "0123456789ABCDEFabcdef-+XxPp";
        _Elem _Atoms[sizeof(_Src)];
        const auto& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Loc);
        _Ctype_fac.widen(::std:: begin(_Src), ::std:: end(_Src), _Atoms);

        const _Elem _Positive_sign = _Atoms[_Offset_pos_sign];
        const _Elem _Negative_sign = _Atoms[_Offset_neg_sign];
        const _Elem _Zero_wc       = _Atoms[0];

        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();

        bool _Bad_grouping = false;

        
        if (!_Grouping.empty()) {
            while (_First != _Last && *_First == _Kseparator) {
                ++_First;
                _Bad_grouping = true;
            }
        }

        if (_First != _Last) {
            if (*_First == _Positive_sign) { 
                *_Ptr++ = '+';
                ++_First;
            } else if (*_First == _Negative_sign) { 
                *_Ptr++ = '-';
                ++_First;
            }
        }

        *_Ptr++ = '0'; 

        bool _Parse_hex                = false;
        bool _Seendigit                = false; 
        char _Initial_dec_leading_zero = '\0';
        if (_First != _Last && *_First == _Zero_wc) {
            ++_First;
            if (_First == _Last) { 
                *_Ptr = '\0';
                return {10, _Bad_grouping};
            }

            if (*_First == _Atoms[_Offset_lower_x] || *_First == _Atoms[_Offset_upper_x]) { 
                _Parse_hex = true;
                ++_First; 
                *_Ptr++ = 'x';
            } else {
                _Seendigit = true;
                ++_Initial_dec_leading_zero;
            }
        }

        bool _Has_unaccumulated_digits = false;
        int _Significant               = 0; 
        ptrdiff_t _Power_of_rep_base   = 0; 

        const size_t _Offset_digit_end = _Parse_hex ? _Offset_hex_digit_end : _Offset_dec_digit_end;
        if (_Grouping.empty()) {
            for (size_t _Idx; _First != _Last && (_Idx = ::std:: _Find_elem(_Atoms, *_First)) < _Offset_digit_end;
                 _Seendigit = true, (void) ++_First) {
                if (_Significant >= _Max_sig_dig) {
                    ++_Power_of_rep_base; 
                    if (_Idx > 0) {
                        _Has_unaccumulated_digits = true;
                    }
                } else if (_Idx != 0 || _Significant != 0) { 
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                }
            }
        } else {
            
            while (_First != _Last && *_First == _Kseparator) {
                ++_First;
                _Bad_grouping = true;
            }

            string _Groups(1, _Initial_dec_leading_zero); 
            size_t _Groups_arr_idx = 0;

            for (; _First != _Last; ++_First) {
                const size_t _Idx = ::std:: _Find_elem(_Atoms, *_First);
                if (_Idx < _Offset_digit_end) { 
                    _Seendigit = true;
                    if (_Significant >= _Max_sig_dig) {
                        ++_Power_of_rep_base; 
                        if (_Idx > 0) {
                            _Has_unaccumulated_digits = true;
                        }
                    } else if (_Idx != 0 || _Significant != 0) { 
                        *_Ptr++ = _Src[_Idx];
                        ++_Significant;
                    }

                    if (_Groups[_Groups_arr_idx] != 127) {
                        ++_Groups[_Groups_arr_idx];
                    }
                } else if (*_First != _Kseparator) {
                    break; 
                } else if (_Groups[_Groups_arr_idx] == '\0') {
                    _Bad_grouping = true; 
                } else { 
                    _Groups.push_back('\0');
                    ++_Groups_arr_idx;
                }
            }

            if (_Groups_arr_idx != 0) {
                if (_Groups[_Groups_arr_idx] > '\0') {
                    ++_Groups_arr_idx; 
                } else {
                    _Bad_grouping = true; 
                }
            }

            
            while (_First != _Last && *_First == _Kseparator) {
                ++_First;
                _Bad_grouping = true;
            }

            const char* _Grouping_iter      = _Grouping.data();
            const char* const _Grouping_end = _Grouping_iter + _Grouping.size();
            char _Current_grouping_count    = '\0';
            while (!_Bad_grouping && _Groups_arr_idx > 0) {
                if (_Grouping_iter != _Grouping_end) { 
                    _Current_grouping_count = *_Grouping_iter; 
                    ++_Grouping_iter;
                }

                --_Groups_arr_idx;
                if ((_Current_grouping_count > '\0' && _Current_grouping_count != 127)
                    && ((_Groups_arr_idx > 0 && _Groups[_Groups_arr_idx] != _Current_grouping_count)
                        || (_Groups_arr_idx == 0 && _Groups[_Groups_arr_idx] > _Current_grouping_count))) {
                    _Bad_grouping = true; 
                }
                
            }
        }

        if (_Parse_hex && _Seendigit && _Significant == 0) {
            
            *_Ptr++ = '0'; 
        }

        const char _Decimal_point = :: localeconv()->decimal_point[0];
        if (_First != _Last && *_First == _Punct_fac.decimal_point()) { 
            *_Ptr++ = _Decimal_point;
            ++_First;
        }

        if (_Significant == 0) { 
            for (; _First != _Last && *_First == _Zero_wc; _Seendigit = true, (void) ++_First) {
                --_Power_of_rep_base; 
            }
        }

        for (size_t _Idx; _First != _Last && (_Idx = ::std:: _Find_elem(_Atoms, *_First)) < _Offset_digit_end;
             _Seendigit = true, (void) ++_First) {
            if (_Significant < _Max_sig_dig) { 
                *_Ptr++ = _Src[_Idx];
                ++_Significant;
            } else if (_Idx > 0) {
                _Has_unaccumulated_digits = true; 
            }
        }

        if (_Has_unaccumulated_digits) { 
            char& _Last_got_digit = _Ptr[-1] == _Decimal_point ? _Ptr[-2] : _Ptr[-1];
            if (_Last_got_digit == '0' || _Last_got_digit == (_Parse_hex ? '8' : '5')) {
                ++_Last_got_digit;
            }
        }

        const _Elem _Lower_exp_wc = _Atoms[_Parse_hex ? _Offset_lower_p : _Offset_lower_e]; 
        const _Elem _Upper_exp_wc = _Atoms[_Parse_hex ? _Offset_upper_p : _Offset_upper_e]; 

        bool _Exponent_part_negative = false;
        ptrdiff_t _Exponent_part     = 0;
        if (_Seendigit && _First != _Last
            && (*_First == _Lower_exp_wc || *_First == _Upper_exp_wc)) { 
            ++_First;
            _Seendigit   = false;
            _Significant = 0;

            if (_First != _Last) {
                if (*_First == _Positive_sign) { 
                    ++_First;
                } else if (*_First == _Negative_sign) { 
                    _Exponent_part_negative = true;
                    ++_First;
                }
            }

            for (; _First != _Last && *_First == _Zero_wc; ++_First) { 
                _Seendigit = true;
            }

            if (_Seendigit) {
                *_Ptr++ = '0'; 
            }

            for (size_t _Idx; _First != _Last && (_Idx = ::std:: _Find_elem(_Atoms, *_First)) < _Offset_dec_digit_end;
                 _Seendigit = true, (void) ++_First) {
                if (_Exponent_part < 9223372036854775807i64 / 10
                    || (_Exponent_part == 9223372036854775807i64 / 10
                        && static_cast<ptrdiff_t>(_Idx) <= 9223372036854775807i64 % 10)) { 
                    _Exponent_part = _Exponent_part * 10 + static_cast<ptrdiff_t>(_Idx);
                } else {
                    _Exponent_part = 9223372036854775807i64; 
                }
            }

            if (_Exponent_part_negative) {
                _Exponent_part = -_Exponent_part;
            }
        }

        if (!_Seendigit) {
            return {0, false};
        }

        constexpr int _Dec_exp_abs_bound = 1100; 
        constexpr int _Hex_exp_abs_bound = 4200; 

        const ptrdiff_t _Exp_abs_bound     = _Parse_hex ? _Hex_exp_abs_bound : _Dec_exp_abs_bound;
        const ptrdiff_t _Exp_rep_abs_bound = _Parse_hex ? _Hex_exp_abs_bound / 4 : _Dec_exp_abs_bound;

        
        
        
        for (ptrdiff_t _Power_of_rep_adjusted = _Power_of_rep_base;;) {
            if (_Exponent_part >= 0 && _Power_of_rep_adjusted >= 0
                && (_Exponent_part >= _Exp_abs_bound || _Power_of_rep_adjusted >= _Exp_rep_abs_bound)) {
                _Exponent_part = _Exp_abs_bound;
                break;
            } else if (_Exponent_part <= 0 && _Power_of_rep_adjusted <= 0
                       && (_Exponent_part <= -_Exp_abs_bound || _Power_of_rep_adjusted <= -_Exp_rep_abs_bound)) {
                _Exponent_part = -_Exp_abs_bound;
                break;
            } else if (::std:: abs(_Exponent_part) <= _Exp_abs_bound
                       && ::std:: abs(_Power_of_rep_adjusted) <= _Exp_rep_abs_bound) {
                
                _Exponent_part += _Parse_hex ? _Power_of_rep_adjusted * 4 : _Power_of_rep_adjusted;
                if (_Exponent_part > _Exp_abs_bound) {
                    _Exponent_part = _Exp_abs_bound;
                } else if (_Exponent_part < -_Exp_abs_bound) {
                    _Exponent_part = -_Exp_abs_bound;
                }
                break;
            } else {
                
                
                const ptrdiff_t _Exponent_part_preadjustment_round_up =
                    _Parse_hex ? (::std:: abs(_Exponent_part) - 1) / 4 + 1 : ::std:: abs(_Exponent_part);
                const ptrdiff_t _Exp_rep_adjustment =
                    (::std:: min)(_Exponent_part_preadjustment_round_up, ::std:: abs(_Power_of_rep_base));

                if (_Exponent_part >= 0) {
                    _Exponent_part -= _Parse_hex ? _Exp_rep_adjustment * 4 : _Exp_rep_adjustment;
                    _Power_of_rep_adjusted += _Exp_rep_adjustment;
                } else {
                    _Exponent_part += _Parse_hex ? _Exp_rep_adjustment * 4 : _Exp_rep_adjustment;
                    _Power_of_rep_adjusted -= _Exp_rep_adjustment;
                }
            }
        }

        if (_Exponent_part != 0) {
            *_Ptr++ = _Parse_hex ? 'p' : 'e';
            if (_Exponent_part < 0) {
                *_Ptr++ = '-';
            }

            char* const _Rev_begin = _Ptr;
            for (ptrdiff_t _Exponent_part_abs = ::std:: abs(_Exponent_part); _Exponent_part_abs != 0;
                 _Exponent_part_abs /= 10) {
                *_Ptr++ = static_cast<char>('0' + _Exponent_part_abs % 10);
            }
            ::std:: reverse(_Rev_begin, _Ptr);
        }

        *_Ptr = '\0';
        return {static_cast<int8_t>(_Parse_hex ? 16 : 10), _Bad_grouping};
    }

    
    int __cdecl _Getifld(
        char* _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield, const locale& _Loc) const {
        
        static constexpr char _Src[] = "0123456789ABCDEFabcdef-+Xx"; 
        const char* volatile _Ptr    = _Src;
        (void) _Ptr;

        const auto _Parse_result = _Parse_int_with_locale(_Ac, _First, _Last, _Basefield, _Loc);
        if (_Parse_result._Base < 0 || _Parse_result._Bad_grouping) { 
            *_Ac = '\0';
        }
        return _Parse_result._Base < 0 ? ~_Parse_result._Base : _Parse_result._Base;
    }






    
    int __cdecl _Getffld(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase, int* _Phexexp) const {
        
        static constexpr char _Src[] = "0123456789-+Ee"; 
        const char* volatile _Ptr    = &_Src[0];
        (void) _Ptr;
        const int _Max_sig_dig   = (*_Phexexp == 1000000000 ? 768 : 36);
        const auto _Parse_result = _Parse_fp_with_locale(_Ac, _Max_sig_dig, _First, _Last, _Iosbase.getloc());
        if (_Parse_result._Base == 0 || _Parse_result._Bad_grouping) { 
            *_Ac = '\0';
        }

        if (_Parse_result._Base == 16) {
            *_Phexexp = 0; 
        }
        return 0; 
    }

    
    int __cdecl _Getffldx(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase, int* _Phexexp) const {
        
        static constexpr char _Src[] = "0123456789ABCDEFabcdef-+XxPp"; 
        const char* volatile _Ptr    = &_Src[0];
        (void) _Ptr;
        const int _Max_sig_dig   = (*_Phexexp == 1000000000 ? 768 : 36);
        const auto _Parse_result = _Parse_fp_with_locale(_Ac, _Max_sig_dig, _First, _Last, _Iosbase.getloc());
        if (_Parse_result._Base == 0 || _Parse_result._Bad_grouping) { 
            *_Ac = '\0';
        }

        if (_Parse_result._Base == 16) {
            *_Phexexp = 0; 
        }
        return 0; 
    }




};






template <class _Elem, class _InIt>
 locale::id num_get<_Elem, _InIt>::id;





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) {
        
        if constexpr (is_same_v<_Ty, double>) {
            return ((53 - 1) + 3) / 4;
        } else if constexpr (is_same_v<_Ty, long double>) {
            return ((53 - 1) + 3) / 4;
        } else {
            static_assert(_Always_false<_Ty>, "Expected only double or long double here (not float).");
        }
    }

    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;
    }
}

 extern "C++" 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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 * _Max_int_dig];
        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 * _Max_int_dig];
        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 * _Max_int_dig];
        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 * _Max_int_dig];
        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_v2(_Dest, _Iosbase, _Fill, _Buf.c_str(), _Ngen, (::std:: isnan)(_Val));
    }

    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_v2(_Dest, _Iosbase, _Fill, _Buf.c_str(), _Ngen, (::std:: isnan)(_Val));
    }
#pragma warning(pop)

    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { 
        char _Buf[2 * _Max_int_dig];

        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 { 
        return _Fput_v2(_Dest, _Iosbase, _Fill, _Buf, _Count, false);
    }

    template <int = 0> 
    _OutIt _Fput_v2(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const char* _Buf, size_t _Count,
        bool _Is_nan_val) 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();
        }

        if (!_Is_nan_val) {
            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;




template  locale::id numpunct<char>::id;
template class __declspec(dllimport) num_get<char, istreambuf_iterator<char, char_traits<char>>>;
template class __declspec(dllimport) num_put<char, ostreambuf_iterator<char, char_traits<char>>>;

template  locale::id numpunct<wchar_t>::id;
template class __declspec(dllimport) num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
template class __declspec(dllimport) num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
#line 1660 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"








#line 1669 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"




}


#pragma warning(pop)
#pragma pack(pop)
#line 1679 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"
#line 1680 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocnum"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
 extern "C++" 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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"

    void  setstate(iostate _State, bool _Reraise = false) {
        
        clear(rdstate() | _State, _Reraise);
    }





#line 60 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"

    basic_ios&  copyfmt(const basic_ios& _Right) { 
        _Tiestr = _Right.tie();
        _Fillch = _Right.fill();
        ios_base::copyfmt(_Right);
        return *this;
    }

    _Myos*  tie() const noexcept  {
        return _Tiestr;
    }

    _Myos*  tie(_Myos* _Newtie) noexcept  { 
        _Myos* _Oldtie = _Tiestr;
        _Tiestr        = _Newtie;
        return _Oldtie;
    }

    [[nodiscard]] _Mysb*  rdbuf() const noexcept  {
        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 noexcept  {
        return _Fillch;
    }

    _Elem  fill(_Elem _Newfill) noexcept  { 
        _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) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            _Mystrbuf = nullptr;
            _Tiestr   = nullptr;
            this->swap(_Right);
        }
    }

    void  move(basic_ios&& _Right) noexcept  {
        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) noexcept  {
        
        _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;
};




template class __declspec(dllimport) basic_ios<char, char_traits<char>>;
template class __declspec(dllimport) basic_ios<wchar_t, char_traits<wchar_t>>;
#line 179 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"




#line 184 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 310 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"

}



#pragma warning(pop)
#pragma pack(pop)
#line 318 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"
#line 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ios"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"





#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) 

 extern "C++" 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) noexcept(false) {
        _Myios::init();
        _Myios::move(::std:: move(_Right));
    }

    basic_ostream&  operator=(basic_ostream&& _Right) noexcept  {
        this->swap(_Right);
        return *this;
    }

    void  swap(basic_ostream& _Right) noexcept  {
        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 118 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"

#line 120 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"
            const bool _Zero_uncaught_exceptions = ::std:: uncaught_exceptions() == 0;
#line 122 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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() noexcept { 
        _Osfx();
    }

    void  _Osfx() noexcept { 
        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;
    }






#line 473 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"


    template <class = void> 
    basic_ostream& operator<<(nullptr_t) { 
        return *this << "nullptr";
    }
#line 480 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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{off_type{-1}};
    }
};

#pragma vtordisp(pop) 



















































template class __declspec(dllimport) basic_ostream<char, char_traits<char>>;
template class __declspec(dllimport) basic_ostream<wchar_t, char_traits<wchar_t>>;
#line 680 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"




#line 685 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 964 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 973 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 994 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
        ios_base::iostate _State = ios_base::goodbit;
        const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
        if (!_Ok) {
            _State |= ios_base::badbit;
        } else {
            try {
            const bool _Emit_failed = !_Sync_buf_ptr->_Do_emit();
            if (_Emit_failed) {
                _State |= ios_base::badbit;
            }
            } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
        }
        _Ostr.setstate(_State);
    }
    return _Ostr;
}







#line 1078 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"
#line 1079 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1298 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"
#line 1299 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ostream"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) 

 extern "C++" 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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(false) : _Chcount(_Right._Chcount) {
        _Myios::init();
        _Myios::move(::std:: move(_Right));
        _Right._Chcount = 0;
    }

    basic_istream&  operator=(basic_istream&& _Right) noexcept  {
        this->swap(_Right);
        return *this;
    }

    void  swap(basic_istream& _Right) noexcept  {
        _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() noexcept {
        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 noexcept  {
        
        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{off_type{-1}};
    }

private:
    streamsize _Chcount{}; 
};

#pragma vtordisp(pop) 























template class __declspec(dllimport) basic_istream<char, char_traits<char>>;
template class __declspec(dllimport) basic_istream<wchar_t, char_traits<wchar_t>>;
#line 719 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\istream"




#line 724 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\istream"

 extern "C++" 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) noexcept(false)
        : _Myis(_Right.rdbuf(), false), _Myos(_Noinit, false) {
        _Myios::init();
        _Myios::move(::std:: move(_Right));
    }

    basic_iostream&  operator=(basic_iostream&& _Right) noexcept  {
        this->swap(_Right);
        return *this;
    }

    void  swap(basic_iostream& _Right) noexcept  {
        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 {}
};




template class __declspec(dllimport) basic_iostream<char, char_traits<char>>;
template class __declspec(dllimport) basic_iostream<wchar_t, char_traits<wchar_t>>;
#line 772 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\istream"




#line 777 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 859 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 938 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\istream"
#line 939 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\istream"
#pragma external_header(pop)
#line 27 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"





#pragma once






#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"


#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>
struct _Deleted_copy : _Base { 
    using _Base::_Base;

    _Deleted_copy()                                = default;
    _Deleted_copy(const _Deleted_copy&)            = delete;
    _Deleted_copy(_Deleted_copy&&)                 = default;
    _Deleted_copy& operator=(const _Deleted_copy&) = default;
    _Deleted_copy& operator=(_Deleted_copy&&)      = default;
};

template <class _Base, class... _Types>
using _SMF_control_copy = conditional_t<conjunction_v<is_trivially_copy_constructible<_Types>...>, _Base,
    conditional_t<conjunction_v<is_copy_constructible<_Types>...>, _Non_trivial_copy<_Base>, _Deleted_copy<_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>
struct _Deleted_move : _SMF_control_copy<_Base, _Types...> { 
    using _Mybase = _SMF_control_copy<_Base, _Types...>;
    using _Mybase::_Mybase;

    _Deleted_move()                                = default;
    _Deleted_move(const _Deleted_move&)            = default;
    _Deleted_move(_Deleted_move&&)                 = delete;
    _Deleted_move& operator=(const _Deleted_move&) = default;
    _Deleted_move& operator=(_Deleted_move&&)      = default;
};

template <class _Base, class... _Types>
using _SMF_control_move =
    conditional_t<conjunction_v<is_trivially_move_constructible<_Types>...>, _SMF_control_copy<_Base, _Types...>,
        conditional_t<conjunction_v<is_move_constructible<_Types>...>, _Non_trivial_move<_Base, _Types...>,
            _Deleted_move<_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 170 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xsmf_control.h"
#line 171 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xsmf_control.h"
#pragma external_header(pop)
#line 22 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
};

[[noreturn]] inline void _Throw_bad_optional_access() {
    throw bad_optional_access{};
}

struct _Nontrivial_dummy_type {
    constexpr _Nontrivial_dummy_type() noexcept {
        
    }
};
;





#line 69 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"

template <class _Ty, bool = is_trivially_destructible_v<_Ty>>
struct _Optional_destruct_base { 
    union {
        _Nontrivial_dummy_type _Dummy;
        remove_cv_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) noexcept(
        is_nothrow_constructible_v<_Ty, _Types...>)
        : _Value(::std:: forward<_Types>(_Args)...), _Has_value{true} {} 






#line 91 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"

    constexpr void reset() noexcept {
        _Has_value = false;
    }
};

template <class _Ty>
struct _Optional_destruct_base<_Ty, false> { 
    union {
        _Nontrivial_dummy_type _Dummy;
        remove_cv_t<_Ty> _Value;
    };
    bool _Has_value;

    constexpr ~_Optional_destruct_base() noexcept {
        if (_Has_value) {
            _Value.~_Ty();
        }
    }

    constexpr _Optional_destruct_base() noexcept : _Dummy{}, _Has_value{false} {} 

    template <class... _Types>
    constexpr explicit _Optional_destruct_base(in_place_t, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty, _Types...>)
        : _Value(::std:: forward<_Types>(_Args)...), _Has_value{true} {} 






#line 124 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {
            _Value.~_Ty();
            _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) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
        
        ;
        _Construct_in_place(this->_Value, ::std:: forward<_Types>(_Args)...);
        this->_Has_value = true;
        return this->_Value;
    }

    template <class _Ty2>
    constexpr void _Assign(_Ty2&& _Right) noexcept(
        is_nothrow_assignable_v<_Ty&, _Ty2>&& is_nothrow_constructible_v<_Ty, _Ty2>) {
        
        if (this->_Has_value) {
            static_cast<_Ty&>(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 {

        do { if (this->_Has_value) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 186, 0, "%s", "Cannot access value of empty optional")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot access value of empty optional\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 186, 0); } while (false); } ; } while (false);
#line 188 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
        return this->_Value;
    }

    [[nodiscard]] constexpr const _Ty& operator*() const& noexcept {

        do { if (this->_Has_value) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 193, 0, "%s", "Cannot access value of empty optional")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot access value of empty optional\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 193, 0); } while (false); } ; } while (false);
#line 195 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
        return this->_Value;
    }

    [[nodiscard]] constexpr _Ty&& operator*() && noexcept {

        do { if (this->_Has_value) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 200, 0, "%s", "Cannot access value of empty optional")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot access value of empty optional\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 200, 0); } while (false); } ; } while (false);
#line 202 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
        return ::std:: move(this->_Value);
    }

    [[nodiscard]] constexpr const _Ty&& operator*() const&& noexcept {

        do { if (this->_Has_value) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 207, 0, "%s", "Cannot access value of empty optional")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot access value of empty optional\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 207, 0); } while (false); } ; } while (false);
#line 209 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 (N4950 [optional.optional.general]/3).");
    static_assert(is_object_v<_Ty> && is_destructible_v<_Ty> && !is_array_v<_Ty>,
        "T in optional<T> must meet the Cpp17Destructible requirements (N4950 [optional.optional.general]/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) noexcept(
        is_nothrow_constructible_v<_Ty, _Types...>) 
        : _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) noexcept(
        is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>) 
        : _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>>,
        negation<conjunction<is_same<remove_cv_t<_Ty>, bool>, _Is_specialization<_Remove_cvref_t<_Ty2>, optional>>>,
        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) noexcept(is_nothrow_constructible_v<_Ty, _Ty2>) 
        : _Mybase(in_place, ::std:: forward<_Ty2>(_Right)) {}

    template <class _Ty2>
    struct _AllowUnwrapping
        : bool_constant<disjunction_v<is_same<remove_cv_t<_Ty>, bool>,
              negation<disjunction<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) noexcept(
        is_nothrow_constructible_v<_Ty, const _Ty2&>)  {
        if (_Right) {
            this->_Construct(*_Right);
        }
    }

    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) noexcept(is_nothrow_constructible_v<_Ty, _Ty2>)  {
        if (_Right) {
            this->_Construct(::std:: move(*_Right));
        }
    }






#line 283 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
        is_nothrow_assignable_v<_Ty&, _Ty2>&& is_nothrow_constructible_v<_Ty, _Ty2>)  {
        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) noexcept(
        is_nothrow_assignable_v<_Ty&, const _Ty2&>&& is_nothrow_constructible_v<_Ty, const _Ty2&>)  {
        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) noexcept(
        is_nothrow_assignable_v<_Ty&, _Ty2>&& is_nothrow_constructible_v<_Ty, _Ty2>)  {
        if (_Right) {
            this->_Assign(::std:: move(*_Right));
        } else {
            reset();
        }

        return *this;
    }

    template <class... _Types>
    constexpr _Ty& emplace(_Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty, _Types...>)  {
        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) noexcept(
        is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>)  {
        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 (N4950 [optional.swap]/1).");
        static_assert(!is_move_constructible_v<_Ty> || is_swappable_v<_Ty>,
            "optional<T>::swap requires T to be swappable (N4950 [optional.swap]/2).");
        using ::std:: swap;
        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(**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 {

        do { if (this->_Has_value) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 375, 0, "%s", "Cannot access value of empty optional")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot access value of empty optional\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 375, 0); } while (false); } ; } while (false);
#line 377 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
        return ::std:: addressof(this->_Value);
    }
    [[nodiscard]] constexpr _Ty* operator->() noexcept {

        do { if (this->_Has_value) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 381, 0, "%s", "Cannot access value of empty optional")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot access value of empty optional\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional", 381, 0); } while (false); } ; } while (false);
#line 383 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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> "
            "(N4950 [optional.observe]/15 as modified by LWG-3424).");
        static_assert(is_convertible_v<_Ty2, _Ty>,
            "optional<T>::value_or(U) requires U to be convertible to T (N4950 [optional.observe]/15).");

        if (this->_Has_value) {
            return static_cast<const _Ty&>(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> "
            "(N4950 [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 (N4950 [optional.observe]/17).");

        if (this->_Has_value) {
            return static_cast<_Ty&&>(this->_Value);
        }

        return static_cast<remove_cv_t<_Ty>>(::std:: forward<_Ty2>(_Right));
    }





































































































































































#line 618 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left == *_Right))) 

    requires requires {
        { *_Left == *_Right } -> _Implicitly_convertible_to<bool>;
    }
#line 633 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
{
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left == *_Right;
    }
    return _Left_has_value == _Right_has_value;
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator!=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left != *_Right))) 

    requires requires {
        { *_Left != *_Right } -> _Implicitly_convertible_to<bool>;
    }
#line 650 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
{
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left != *_Right;
    }
    return _Left_has_value != _Right_has_value;
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator<(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left < *_Right))) 

    requires requires {
        { *_Left < *_Right } -> _Implicitly_convertible_to<bool>;
    }
#line 667 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
{
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left < *_Right;
    }
    return _Left_has_value < _Right_has_value;
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator>(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left > *_Right))) 

    requires requires {
        { *_Left > *_Right } -> _Implicitly_convertible_to<bool>;
    }
#line 684 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
{
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left > *_Right;
    }
    return _Left_has_value > _Right_has_value;
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator<=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left <= *_Right))) 

    requires requires(const _Ty1& _Elem1, const _Ty2& _Elem2) {
        { *_Left <= *_Right } -> _Implicitly_convertible_to<bool>;
    }
#line 701 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
{
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left <= *_Right;
    }
    return _Left_has_value <= _Right_has_value;
}

 template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator>=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left >= *_Right))) 

    requires requires {
        { *_Left >= *_Right } -> _Implicitly_convertible_to<bool>;
    }
#line 718 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
{
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left >= *_Right;
    }
    return _Left_has_value >= _Right_has_value;
}


 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) noexcept(noexcept(*_Left <=> *_Right))  {
    const bool _Left_has_value  = _Left.has_value();
    const bool _Right_has_value = _Right.has_value();
    if (_Left_has_value && _Right_has_value) {
        return *_Left <=> *_Right;
    }

    return _Left_has_value <=> _Right_has_value;
}
#line 740 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 802 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left == _Right)))  {
    if (_Left) {
        return *_Left == _Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(_Left == *_Right)))  {
    if (_Right) {
        return _Left == *_Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left != _Right)))  {
    if (_Left) {
        return *_Left != _Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(_Left != *_Right)))  {
    if (_Right) {
        return _Left != *_Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left < _Right)))  {
    if (_Left) {
        return *_Left < _Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(_Left < *_Right)))  {
    if (_Right) {
        return _Left < *_Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left > _Right)))  {
    if (_Left) {
        return *_Left > _Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(_Left > *_Right)))  {
    if (_Right) {
        return _Left > *_Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left <= _Right)))  {
    if (_Left) {
        return *_Left <= _Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(_Left <= *_Right)))  {
    if (_Right) {
        return _Left <= *_Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(*_Left >= _Right)))  {
    if (_Left) {
        return *_Left >= _Right;
    }
    return 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) noexcept(
    noexcept(_Fake_copy_init<bool>(_Left >= *_Right)))  {
    if (_Right) {
        return _Left >= *_Right;
    }
    return true;
}



 template <class _Ty1, class _Ty2>
    requires (!_Derived_from_specialization_of<_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)
        noexcept(noexcept(*_Left <=> _Right))  {
    
    if (_Left) {
        return *_Left <=> _Right;
    }

    return strong_ordering::less;
}
#line 949 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, enable_if_t<is_constructible_v<decay_t<_Ty>, _Ty>, int> = 0> 
[[nodiscard]] constexpr optional<decay_t<_Ty>> make_optional(_Ty&& _Value) noexcept(
    noexcept(optional<decay_t<_Ty>>{::std:: forward<_Ty>(_Value)}))  {
    return optional<decay_t<_Ty>>{::std:: forward<_Ty>(_Value)};
}
 template <class _Ty, class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
[[nodiscard]] constexpr optional<_Ty> make_optional(_Types&&... _Args) noexcept(
    noexcept(optional<_Ty>{in_place, ::std:: forward<_Types>(_Args)...}))  {
    return optional<_Ty>{in_place, ::std:: forward<_Types>(_Args)...};
}
 template <class _Ty, class _Elem, class... _Types,
    enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
[[nodiscard]] constexpr optional<_Ty> make_optional(initializer_list<_Elem> _Ilist, _Types&&... _Args) noexcept(
    noexcept(optional<_Ty>{in_place, _Ilist, ::std:: forward<_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 992 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
#line 993 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
#line 994 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\optional"
#pragma external_header(pop)
#line 29 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"





#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>
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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_) : _Mystate(0), _Al(_Al_) {
        _Assign_rv(::std:: move(_Right));
    }
#line 74 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"

    basic_stringbuf(basic_stringbuf&& _Right) : _Mystate(0) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_stringbuf& operator=(basic_stringbuf&& _Right) noexcept  {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_stringbuf&& _Right) noexcept {
        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) {
                do { if (_Al == _Right._Al) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream", 95, 0, "%s", "The allocators of basic_stringbuf should propagate or be equal on swap.")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"The allocators of basic_stringbuf should propagate or be equal on swap.\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream", 95, 0); } while (false); } ; } while (false);
#line 96 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
            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 227 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(_Allocate_at_least_helper(_Al, _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, _Newptr, _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 bool _Need_read_but_cannot  = (_Mode & ios_base::in) != 0 && (_Mystate & _Noread) != 0;
        const bool _Need_write_but_cannot = (_Mode & ios_base::out) != 0 && (_Mystate & _Constant) != 0;
        if (_Need_read_but_cannot || _Need_write_but_cannot) {
            return pos_type{off_type{-1}};
        }

        
        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;
                    }
                }
            }

            [[fallthrough]];
        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 bool _Need_read_but_cannot  = (_Mode & ios_base::in) != 0 && (_Mystate & _Noread) != 0;
        const bool _Need_write_but_cannot = (_Mode & ios_base::out) != 0 && (_Mystate & _Constant) != 0;
        if (_Need_read_but_cannot || _Need_write_but_cannot) {
            return pos_type{off_type{-1}};
        }

        
        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};
    }

    void _Init(const _Elem* _Ptr, const _Mysize_type _Count, int _State) {
        
        _State &= ~_From_rvalue;

        if (_Count > 2147483647) { 
            _Xbad_alloc();
        }

        if (_Count != 0 && (_State & (_Noread | _Constant)) != (_Noread | _Constant)) {
            
            _Mysize_type _Newsize = _Count;
            const auto _Pnew      = _Unfancy(_Allocate_at_least_helper(_Al, _Newsize));
            _Traits::copy(_Pnew, _Ptr, _Count);
            _Seekhigh = _Pnew + _Newsize;

            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, _Pnew, _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, _Pnew, _Pnew);
        } else {
            _Mysb::setg(_Pnew, _Pnew, _Seekhigh);
        }

        _Mystate = _State | _Allocated | _From_rvalue;
    }
#line 493 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept { 
        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 558 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 587 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"

    basic_istringstream(basic_istringstream&& _Right) : _Mybase(::std:: addressof(_Stringbuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_istringstream& operator=(basic_istringstream&& _Right) noexcept  {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_istringstream&& _Right) noexcept {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Stringbuffer._Assign_rv(::std:: move(_Right._Stringbuffer));
        }
    }

    void swap(basic_istringstream& _Right) noexcept  {
        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 noexcept  {
        return const_cast<_Mysb*>(::std:: addressof(_Stringbuffer));
    }


    [[nodiscard]] _Mystr str() const&


#line 625 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 656 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept  {
    _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 678 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 707 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"

    basic_ostringstream(basic_ostringstream&& _Right) : _Mybase(::std:: addressof(_Stringbuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_ostringstream& operator=(basic_ostringstream&& _Right) noexcept  {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_ostringstream&& _Right) noexcept {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Stringbuffer._Assign_rv(::std:: move(_Right._Stringbuffer));
        }
    }

    void swap(basic_ostringstream& _Right) noexcept  {
        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 noexcept  {
        return const_cast<_Mysb*>(::std:: addressof(_Stringbuffer));
    }


    [[nodiscard]] _Mystr str() const&


#line 745 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 776 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept  {
    _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 804 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 833 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"

    basic_stringstream(basic_stringstream&& _Right) : _Mybase(::std:: addressof(_Stringbuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_stringstream& operator=(basic_stringstream&& _Right) noexcept  {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_stringstream&& _Right) noexcept {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Stringbuffer._Assign_rv(::std:: move(_Right._Stringbuffer));
        }
    }

    void swap(basic_stringstream& _Right) noexcept  {
        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 noexcept  {
        return const_cast<_Mysb*>(::std:: addressof(_Stringbuffer));
    }


    [[nodiscard]] _Mystr str() const&


#line 871 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 902 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept  {
    _Left.swap(_Right);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 918 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"
#line 919 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\sstream"
#pragma external_header(pop)
#line 30 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
template <class _InIt, class _Elem>
ios_base::iostate _Getint_v2(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int& _Val, int& _Digits_read,
    const ctype<_Elem>& _Ctype_fac) { 
    ;
    const int _Hi_digits = (_Hi <= 9 ? 1 : _Hi <= 99 ? 2 : _Hi <= 999 ? 3 : 4);
    char _Ac[_Max_int_dig];
    char* _Ep;
    char* _Ptr = _Ac;
    char _Ch;

    _Digits_read = 0;

    while (_First != _Last && _Digits_read < _Hi_digits && _Ctype_fac.is(ctype_base::space, *_First)) {
        ++_First;
        ++_Digits_read;
    }

    if (_First != _Last && _Digits_read < _Hi_digits) {
        if ((_Ch = _Ctype_fac.narrow(*_First)) == '+') { 
            *_Ptr++ = '+';
            ++_First;
        } else if (_Ch == '-') { 
            *_Ptr++ = '-';
            ++_First;
        }
    }

    for (; _First != _Last && _Digits_read < _Hi_digits && _Ctype_fac.narrow(*_First) == '0'; ++_First) {
        ++_Digits_read; 
    }

    if (_Digits_read > 0) {
        *_Ptr++ = '0'; 
    }

    for (char* const _Pe = &_Ac[_Max_int_dig - 1];
         _First != _Last && '0' <= (_Ch = _Ctype_fac.narrow(*_First)) && _Ch <= '9' && _Digits_read < _Hi_digits;
         ++_Digits_read, (void) ++_First) { 
        *_Ptr = _Ch;
        if (_Ptr < _Pe) {
            ++_Ptr; 
        }
    }

    if (_Digits_read == 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;
}

 extern "C++" struct __declspec(dllimport) time_base 
    : locale::facet 
{
    enum dateorder { 
        no_order,
        dmy,
        mdy,
        ymd,
        ydm
    };

     time_base(size_t _Refs = 0) noexcept 
        : locale::facet(_Refs) {}

     ~time_base() noexcept override {}
};

 extern "C++" 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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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;
        int _Digits_read;
        ios_base::iostate _Res = _Getint_v2(_First, _Last, 0, 9999, _Ans, _Digits_read, _Ctype_fac);

        _State |= _Res; 
        if (!(_Res & ios_base::failbit)) {
            if (_Digits_read <= 2) {
                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':
            _State |= _Getint(_First, _Last, 0, 9999, _Ans, _Ctype_fac);
            if (!(_State & ios_base::failbit)) {
                _Pt->tm_year = _Ans - 1900;
            }
            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 (_First == _Last) {
                _State |= ios_base::failbit;
                break;
            } else 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 { 
        
        int _Digits_read;
        return _Getint_v2(_First, _Last, _Lo, _Hi, _Val, _Digits_read, _Ctype_fac);
    }

    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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 {}
};

 extern "C++" 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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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;
        }

        int& _Errno_ref      = (*_errno()); 
        const int _Old_errno = _Errno_ref;

        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;
            }
        }

        _Errno_ref = _Old_errno;
        return ::std:: copy(&_Str[1], &_Str[_Count], _Dest);
    }

private:
    _Locinfo::_Timevec _Tnames; 
};






template <class _Elem, class _OutIt>
 locale::id time_put<_Elem, _OutIt>::id;





extern "C++" 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);
        }

        int& _Errno_ref      = (*_errno()); 
        const int _Old_errno = _Errno_ref;

        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;
            }
        }

        _Errno_ref = _Old_errno;
        return ::std:: copy(&_Str[1], &_Str[_Count], _Dest);
    }

private:
    _Locinfo::_Timevec _Tnames; 
};






template <class _OutIt>
 locale::id time_put<wchar_t, _OutIt>::id;








































































































































#line 1040 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 {}
};




template class __declspec(dllimport) time_get<char, istreambuf_iterator<char, char_traits<char>>>;
template class __declspec(dllimport) time_put<char, ostreambuf_iterator<char, char_traits<char>>>;
template  void  time_get<char, istreambuf_iterator<char, char_traits<char>>>::_Getvals(
    wchar_t, const _Locinfo&);

template class __declspec(dllimport) time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
template class __declspec(dllimport) time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
template  void 
    time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>::_Getvals(wchar_t, const _Locinfo&);
#line 1069 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xloctime"










#line 1080 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xloctime"
}



#pragma warning(pop)
#pragma pack(pop)
#line 1087 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xloctime"
#line 1088 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xloctime"
#pragma external_header(pop)
#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"




































#pragma once








#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_format_ucd_tables.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    )




namespace std {

template <class _ValueEnum, size_t _NumRanges, bool _Is_binary_property>
struct _Unicode_property_data {
    uint32_t _Lower_bounds[_NumRanges];
    uint16_t _Props_and_size[_NumRanges];
    [[nodiscard]] constexpr _ValueEnum _Get_property_for_codepoint(const uint32_t _Code_point) const noexcept {
        ptrdiff_t _Upper_idx = ::std:: upper_bound(_Lower_bounds, ::std:: end(_Lower_bounds), _Code_point) - _Lower_bounds;
        constexpr auto _No_value_constant = static_cast<_ValueEnum>(0xffui8);
        if (_Upper_idx == 0) {
            return _No_value_constant;
        }
        --_Upper_idx;
        const uint32_t _Lower_bound = _Lower_bounds[_Upper_idx];
        const uint16_t _Data        = _Props_and_size[_Upper_idx];
        ;
        if constexpr (_Is_binary_property) {
            if (_Code_point < _Lower_bound + _Data) {
                return static_cast<_ValueEnum>(0);
            }
        } else {
            const uint16_t _Size   = static_cast<uint16_t>(_Data & 0x0FFF);
            const _ValueEnum _Prop = static_cast<_ValueEnum>((_Data & 0xF000) >> 12);
            if (_Code_point < _Lower_bound + _Size) {
                return _Prop;
            }
        }
        return _No_value_constant;
    }
};


































enum class _Grapheme_Break_property_values : uint8_t {
    _CR_value,
    _Control_value,
    _Extend_value,
    _L_value,
    _LF_value,
    _LV_value,
    _LVT_value,
    _Prepend_value,
    _Regional_Indicator_value,
    _SpacingMark_value,
    _T_value,
    _V_value,
    _ZWJ_value,
    _No_value = 255
};



inline constexpr _Unicode_property_data<_Grapheme_Break_property_values, 1371, false> _Grapheme_Break_property_data{
    {0x0, 0xa, 0xb, 0xd, 0xe, 0x7f, 0xad, 0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x600, 0x610, 0x61c, 0x64b,
        0x670, 0x6d6, 0x6dd, 0x6df, 0x6e7, 0x6ea, 0x70f, 0x711, 0x730, 0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829,
        0x859, 0x890, 0x898, 0x8ca, 0x8e2, 0x8e3, 0x903, 0x93a, 0x93b, 0x93c, 0x93e, 0x941, 0x949, 0x94d, 0x94e, 0x951,
        0x962, 0x981, 0x982, 0x9bc, 0x9be, 0x9bf, 0x9c1, 0x9c7, 0x9cb, 0x9cd, 0x9d7, 0x9e2, 0x9fe, 0xa01, 0xa03, 0xa3c,
        0xa3e, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70, 0xa75, 0xa81, 0xa83, 0xabc, 0xabe, 0xac1, 0xac7, 0xac9, 0xacb, 0xacd,
        0xae2, 0xafa, 0xb01, 0xb02, 0xb3c, 0xb3e, 0xb40, 0xb41, 0xb47, 0xb4b, 0xb4d, 0xb55, 0xb62, 0xb82, 0xbbe, 0xbbf,
        0xbc0, 0xbc1, 0xbc6, 0xbca, 0xbcd, 0xbd7, 0xc00, 0xc01, 0xc04, 0xc3c, 0xc3e, 0xc41, 0xc46, 0xc4a, 0xc55, 0xc62,
        0xc81, 0xc82, 0xcbc, 0xcbe, 0xcbf, 0xcc0, 0xcc2, 0xcc3, 0xcc6, 0xcc7, 0xcca, 0xccc, 0xcd5, 0xce2, 0xcf3, 0xd00,
        0xd02, 0xd3b, 0xd3e, 0xd3f, 0xd41, 0xd46, 0xd4a, 0xd4d, 0xd4e, 0xd57, 0xd62, 0xd81, 0xd82, 0xdca, 0xdcf, 0xdd0,
        0xdd2, 0xdd6, 0xdd8, 0xddf, 0xdf2, 0xe31, 0xe33, 0xe34, 0xe47, 0xeb1, 0xeb3, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37,
        0xf39, 0xf3e, 0xf71, 0xf7f, 0xf80, 0xf86, 0xf8d, 0xf99, 0xfc6, 0x102d, 0x1031, 0x1032, 0x1039, 0x103b, 0x103d,
        0x1056, 0x1058, 0x105e, 0x1071, 0x1082, 0x1084, 0x1085, 0x108d, 0x109d, 0x1100, 0x1160, 0x11a8, 0x135d, 0x1712,
        0x1715, 0x1732, 0x1734, 0x1752, 0x1772, 0x17b4, 0x17b6, 0x17b7, 0x17be, 0x17c6, 0x17c7, 0x17c9, 0x17dd, 0x180b,
        0x180e, 0x180f, 0x1885, 0x18a9, 0x1920, 0x1923, 0x1927, 0x1929, 0x1930, 0x1932, 0x1933, 0x1939, 0x1a17, 0x1a19,
        0x1a1b, 0x1a55, 0x1a56, 0x1a57, 0x1a58, 0x1a60, 0x1a62, 0x1a65, 0x1a6d, 0x1a73, 0x1a7f, 0x1ab0, 0x1b00, 0x1b04,
        0x1b34, 0x1b3b, 0x1b3c, 0x1b3d, 0x1b42, 0x1b43, 0x1b6b, 0x1b80, 0x1b82, 0x1ba1, 0x1ba2, 0x1ba6, 0x1ba8, 0x1baa,
        0x1bab, 0x1be6, 0x1be7, 0x1be8, 0x1bea, 0x1bed, 0x1bee, 0x1bef, 0x1bf2, 0x1c24, 0x1c2c, 0x1c34, 0x1c36, 0x1cd0,
        0x1cd4, 0x1ce1, 0x1ce2, 0x1ced, 0x1cf4, 0x1cf7, 0x1cf8, 0x1dc0, 0x200b, 0x200c, 0x200d, 0x200e, 0x2028, 0x2060,
        0x20d0, 0x2cef, 0x2d7f, 0x2de0, 0x302a, 0x3099, 0xa66f, 0xa674, 0xa69e, 0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa823,
        0xa825, 0xa827, 0xa82c, 0xa880, 0xa8b4, 0xa8c4, 0xa8e0, 0xa8ff, 0xa926, 0xa947, 0xa952, 0xa960, 0xa980, 0xa983,
        0xa9b3, 0xa9b4, 0xa9b6, 0xa9ba, 0xa9bc, 0xa9be, 0xa9e5, 0xaa29, 0xaa2f, 0xaa31, 0xaa33, 0xaa35, 0xaa43, 0xaa4c,
        0xaa4d, 0xaa7c, 0xaab0, 0xaab2, 0xaab7, 0xaabe, 0xaac1, 0xaaeb, 0xaaec, 0xaaee, 0xaaf5, 0xaaf6, 0xabe3, 0xabe5,
        0xabe6, 0xabe8, 0xabe9, 0xabec, 0xabed, 0xac00, 0xac01, 0xac1c, 0xac1d, 0xac38, 0xac39, 0xac54, 0xac55, 0xac70,
        0xac71, 0xac8c, 0xac8d, 0xaca8, 0xaca9, 0xacc4, 0xacc5, 0xace0, 0xace1, 0xacfc, 0xacfd, 0xad18, 0xad19, 0xad34,
        0xad35, 0xad50, 0xad51, 0xad6c, 0xad6d, 0xad88, 0xad89, 0xada4, 0xada5, 0xadc0, 0xadc1, 0xaddc, 0xaddd, 0xadf8,
        0xadf9, 0xae14, 0xae15, 0xae30, 0xae31, 0xae4c, 0xae4d, 0xae68, 0xae69, 0xae84, 0xae85, 0xaea0, 0xaea1, 0xaebc,
        0xaebd, 0xaed8, 0xaed9, 0xaef4, 0xaef5, 0xaf10, 0xaf11, 0xaf2c, 0xaf2d, 0xaf48, 0xaf49, 0xaf64, 0xaf65, 0xaf80,
        0xaf81, 0xaf9c, 0xaf9d, 0xafb8, 0xafb9, 0xafd4, 0xafd5, 0xaff0, 0xaff1, 0xb00c, 0xb00d, 0xb028, 0xb029, 0xb044,
        0xb045, 0xb060, 0xb061, 0xb07c, 0xb07d, 0xb098, 0xb099, 0xb0b4, 0xb0b5, 0xb0d0, 0xb0d1, 0xb0ec, 0xb0ed, 0xb108,
        0xb109, 0xb124, 0xb125, 0xb140, 0xb141, 0xb15c, 0xb15d, 0xb178, 0xb179, 0xb194, 0xb195, 0xb1b0, 0xb1b1, 0xb1cc,
        0xb1cd, 0xb1e8, 0xb1e9, 0xb204, 0xb205, 0xb220, 0xb221, 0xb23c, 0xb23d, 0xb258, 0xb259, 0xb274, 0xb275, 0xb290,
        0xb291, 0xb2ac, 0xb2ad, 0xb2c8, 0xb2c9, 0xb2e4, 0xb2e5, 0xb300, 0xb301, 0xb31c, 0xb31d, 0xb338, 0xb339, 0xb354,
        0xb355, 0xb370, 0xb371, 0xb38c, 0xb38d, 0xb3a8, 0xb3a9, 0xb3c4, 0xb3c5, 0xb3e0, 0xb3e1, 0xb3fc, 0xb3fd, 0xb418,
        0xb419, 0xb434, 0xb435, 0xb450, 0xb451, 0xb46c, 0xb46d, 0xb488, 0xb489, 0xb4a4, 0xb4a5, 0xb4c0, 0xb4c1, 0xb4dc,
        0xb4dd, 0xb4f8, 0xb4f9, 0xb514, 0xb515, 0xb530, 0xb531, 0xb54c, 0xb54d, 0xb568, 0xb569, 0xb584, 0xb585, 0xb5a0,
        0xb5a1, 0xb5bc, 0xb5bd, 0xb5d8, 0xb5d9, 0xb5f4, 0xb5f5, 0xb610, 0xb611, 0xb62c, 0xb62d, 0xb648, 0xb649, 0xb664,
        0xb665, 0xb680, 0xb681, 0xb69c, 0xb69d, 0xb6b8, 0xb6b9, 0xb6d4, 0xb6d5, 0xb6f0, 0xb6f1, 0xb70c, 0xb70d, 0xb728,
        0xb729, 0xb744, 0xb745, 0xb760, 0xb761, 0xb77c, 0xb77d, 0xb798, 0xb799, 0xb7b4, 0xb7b5, 0xb7d0, 0xb7d1, 0xb7ec,
        0xb7ed, 0xb808, 0xb809, 0xb824, 0xb825, 0xb840, 0xb841, 0xb85c, 0xb85d, 0xb878, 0xb879, 0xb894, 0xb895, 0xb8b0,
        0xb8b1, 0xb8cc, 0xb8cd, 0xb8e8, 0xb8e9, 0xb904, 0xb905, 0xb920, 0xb921, 0xb93c, 0xb93d, 0xb958, 0xb959, 0xb974,
        0xb975, 0xb990, 0xb991, 0xb9ac, 0xb9ad, 0xb9c8, 0xb9c9, 0xb9e4, 0xb9e5, 0xba00, 0xba01, 0xba1c, 0xba1d, 0xba38,
        0xba39, 0xba54, 0xba55, 0xba70, 0xba71, 0xba8c, 0xba8d, 0xbaa8, 0xbaa9, 0xbac4, 0xbac5, 0xbae0, 0xbae1, 0xbafc,
        0xbafd, 0xbb18, 0xbb19, 0xbb34, 0xbb35, 0xbb50, 0xbb51, 0xbb6c, 0xbb6d, 0xbb88, 0xbb89, 0xbba4, 0xbba5, 0xbbc0,
        0xbbc1, 0xbbdc, 0xbbdd, 0xbbf8, 0xbbf9, 0xbc14, 0xbc15, 0xbc30, 0xbc31, 0xbc4c, 0xbc4d, 0xbc68, 0xbc69, 0xbc84,
        0xbc85, 0xbca0, 0xbca1, 0xbcbc, 0xbcbd, 0xbcd8, 0xbcd9, 0xbcf4, 0xbcf5, 0xbd10, 0xbd11, 0xbd2c, 0xbd2d, 0xbd48,
        0xbd49, 0xbd64, 0xbd65, 0xbd80, 0xbd81, 0xbd9c, 0xbd9d, 0xbdb8, 0xbdb9, 0xbdd4, 0xbdd5, 0xbdf0, 0xbdf1, 0xbe0c,
        0xbe0d, 0xbe28, 0xbe29, 0xbe44, 0xbe45, 0xbe60, 0xbe61, 0xbe7c, 0xbe7d, 0xbe98, 0xbe99, 0xbeb4, 0xbeb5, 0xbed0,
        0xbed1, 0xbeec, 0xbeed, 0xbf08, 0xbf09, 0xbf24, 0xbf25, 0xbf40, 0xbf41, 0xbf5c, 0xbf5d, 0xbf78, 0xbf79, 0xbf94,
        0xbf95, 0xbfb0, 0xbfb1, 0xbfcc, 0xbfcd, 0xbfe8, 0xbfe9, 0xc004, 0xc005, 0xc020, 0xc021, 0xc03c, 0xc03d, 0xc058,
        0xc059, 0xc074, 0xc075, 0xc090, 0xc091, 0xc0ac, 0xc0ad, 0xc0c8, 0xc0c9, 0xc0e4, 0xc0e5, 0xc100, 0xc101, 0xc11c,
        0xc11d, 0xc138, 0xc139, 0xc154, 0xc155, 0xc170, 0xc171, 0xc18c, 0xc18d, 0xc1a8, 0xc1a9, 0xc1c4, 0xc1c5, 0xc1e0,
        0xc1e1, 0xc1fc, 0xc1fd, 0xc218, 0xc219, 0xc234, 0xc235, 0xc250, 0xc251, 0xc26c, 0xc26d, 0xc288, 0xc289, 0xc2a4,
        0xc2a5, 0xc2c0, 0xc2c1, 0xc2dc, 0xc2dd, 0xc2f8, 0xc2f9, 0xc314, 0xc315, 0xc330, 0xc331, 0xc34c, 0xc34d, 0xc368,
        0xc369, 0xc384, 0xc385, 0xc3a0, 0xc3a1, 0xc3bc, 0xc3bd, 0xc3d8, 0xc3d9, 0xc3f4, 0xc3f5, 0xc410, 0xc411, 0xc42c,
        0xc42d, 0xc448, 0xc449, 0xc464, 0xc465, 0xc480, 0xc481, 0xc49c, 0xc49d, 0xc4b8, 0xc4b9, 0xc4d4, 0xc4d5, 0xc4f0,
        0xc4f1, 0xc50c, 0xc50d, 0xc528, 0xc529, 0xc544, 0xc545, 0xc560, 0xc561, 0xc57c, 0xc57d, 0xc598, 0xc599, 0xc5b4,
        0xc5b5, 0xc5d0, 0xc5d1, 0xc5ec, 0xc5ed, 0xc608, 0xc609, 0xc624, 0xc625, 0xc640, 0xc641, 0xc65c, 0xc65d, 0xc678,
        0xc679, 0xc694, 0xc695, 0xc6b0, 0xc6b1, 0xc6cc, 0xc6cd, 0xc6e8, 0xc6e9, 0xc704, 0xc705, 0xc720, 0xc721, 0xc73c,
        0xc73d, 0xc758, 0xc759, 0xc774, 0xc775, 0xc790, 0xc791, 0xc7ac, 0xc7ad, 0xc7c8, 0xc7c9, 0xc7e4, 0xc7e5, 0xc800,
        0xc801, 0xc81c, 0xc81d, 0xc838, 0xc839, 0xc854, 0xc855, 0xc870, 0xc871, 0xc88c, 0xc88d, 0xc8a8, 0xc8a9, 0xc8c4,
        0xc8c5, 0xc8e0, 0xc8e1, 0xc8fc, 0xc8fd, 0xc918, 0xc919, 0xc934, 0xc935, 0xc950, 0xc951, 0xc96c, 0xc96d, 0xc988,
        0xc989, 0xc9a4, 0xc9a5, 0xc9c0, 0xc9c1, 0xc9dc, 0xc9dd, 0xc9f8, 0xc9f9, 0xca14, 0xca15, 0xca30, 0xca31, 0xca4c,
        0xca4d, 0xca68, 0xca69, 0xca84, 0xca85, 0xcaa0, 0xcaa1, 0xcabc, 0xcabd, 0xcad8, 0xcad9, 0xcaf4, 0xcaf5, 0xcb10,
        0xcb11, 0xcb2c, 0xcb2d, 0xcb48, 0xcb49, 0xcb64, 0xcb65, 0xcb80, 0xcb81, 0xcb9c, 0xcb9d, 0xcbb8, 0xcbb9, 0xcbd4,
        0xcbd5, 0xcbf0, 0xcbf1, 0xcc0c, 0xcc0d, 0xcc28, 0xcc29, 0xcc44, 0xcc45, 0xcc60, 0xcc61, 0xcc7c, 0xcc7d, 0xcc98,
        0xcc99, 0xccb4, 0xccb5, 0xccd0, 0xccd1, 0xccec, 0xcced, 0xcd08, 0xcd09, 0xcd24, 0xcd25, 0xcd40, 0xcd41, 0xcd5c,
        0xcd5d, 0xcd78, 0xcd79, 0xcd94, 0xcd95, 0xcdb0, 0xcdb1, 0xcdcc, 0xcdcd, 0xcde8, 0xcde9, 0xce04, 0xce05, 0xce20,
        0xce21, 0xce3c, 0xce3d, 0xce58, 0xce59, 0xce74, 0xce75, 0xce90, 0xce91, 0xceac, 0xcead, 0xcec8, 0xcec9, 0xcee4,
        0xcee5, 0xcf00, 0xcf01, 0xcf1c, 0xcf1d, 0xcf38, 0xcf39, 0xcf54, 0xcf55, 0xcf70, 0xcf71, 0xcf8c, 0xcf8d, 0xcfa8,
        0xcfa9, 0xcfc4, 0xcfc5, 0xcfe0, 0xcfe1, 0xcffc, 0xcffd, 0xd018, 0xd019, 0xd034, 0xd035, 0xd050, 0xd051, 0xd06c,
        0xd06d, 0xd088, 0xd089, 0xd0a4, 0xd0a5, 0xd0c0, 0xd0c1, 0xd0dc, 0xd0dd, 0xd0f8, 0xd0f9, 0xd114, 0xd115, 0xd130,
        0xd131, 0xd14c, 0xd14d, 0xd168, 0xd169, 0xd184, 0xd185, 0xd1a0, 0xd1a1, 0xd1bc, 0xd1bd, 0xd1d8, 0xd1d9, 0xd1f4,
        0xd1f5, 0xd210, 0xd211, 0xd22c, 0xd22d, 0xd248, 0xd249, 0xd264, 0xd265, 0xd280, 0xd281, 0xd29c, 0xd29d, 0xd2b8,
        0xd2b9, 0xd2d4, 0xd2d5, 0xd2f0, 0xd2f1, 0xd30c, 0xd30d, 0xd328, 0xd329, 0xd344, 0xd345, 0xd360, 0xd361, 0xd37c,
        0xd37d, 0xd398, 0xd399, 0xd3b4, 0xd3b5, 0xd3d0, 0xd3d1, 0xd3ec, 0xd3ed, 0xd408, 0xd409, 0xd424, 0xd425, 0xd440,
        0xd441, 0xd45c, 0xd45d, 0xd478, 0xd479, 0xd494, 0xd495, 0xd4b0, 0xd4b1, 0xd4cc, 0xd4cd, 0xd4e8, 0xd4e9, 0xd504,
        0xd505, 0xd520, 0xd521, 0xd53c, 0xd53d, 0xd558, 0xd559, 0xd574, 0xd575, 0xd590, 0xd591, 0xd5ac, 0xd5ad, 0xd5c8,
        0xd5c9, 0xd5e4, 0xd5e5, 0xd600, 0xd601, 0xd61c, 0xd61d, 0xd638, 0xd639, 0xd654, 0xd655, 0xd670, 0xd671, 0xd68c,
        0xd68d, 0xd6a8, 0xd6a9, 0xd6c4, 0xd6c5, 0xd6e0, 0xd6e1, 0xd6fc, 0xd6fd, 0xd718, 0xd719, 0xd734, 0xd735, 0xd750,
        0xd751, 0xd76c, 0xd76d, 0xd788, 0xd789, 0xd7b0, 0xd7cb, 0xfb1e, 0xfe00, 0xfe20, 0xfeff, 0xff9e, 0xfff0, 0x101fd,
        0x102e0, 0x10376, 0x10a01, 0x10a05, 0x10a0c, 0x10a38, 0x10a3f, 0x10ae5, 0x10d24, 0x10eab, 0x10efd, 0x10f46,
        0x10f82, 0x11000, 0x11001, 0x11002, 0x11038, 0x11070, 0x11073, 0x1107f, 0x11082, 0x110b0, 0x110b3, 0x110b7,
        0x110b9, 0x110bd, 0x110c2, 0x110cd, 0x11100, 0x11127, 0x1112c, 0x1112d, 0x11145, 0x11173, 0x11180, 0x11182,
        0x111b3, 0x111b6, 0x111bf, 0x111c2, 0x111c9, 0x111ce, 0x111cf, 0x1122c, 0x1122f, 0x11232, 0x11234, 0x11235,
        0x11236, 0x1123e, 0x11241, 0x112df, 0x112e0, 0x112e3, 0x11300, 0x11302, 0x1133b, 0x1133e, 0x1133f, 0x11340,
        0x11341, 0x11347, 0x1134b, 0x11357, 0x11362, 0x11366, 0x11370, 0x11435, 0x11438, 0x11440, 0x11442, 0x11445,
        0x11446, 0x1145e, 0x114b0, 0x114b1, 0x114b3, 0x114b9, 0x114ba, 0x114bb, 0x114bd, 0x114be, 0x114bf, 0x114c1,
        0x114c2, 0x115af, 0x115b0, 0x115b2, 0x115b8, 0x115bc, 0x115be, 0x115bf, 0x115dc, 0x11630, 0x11633, 0x1163b,
        0x1163d, 0x1163e, 0x1163f, 0x116ab, 0x116ac, 0x116ad, 0x116ae, 0x116b0, 0x116b6, 0x116b7, 0x1171d, 0x11722,
        0x11726, 0x11727, 0x1182c, 0x1182f, 0x11838, 0x11839, 0x11930, 0x11931, 0x11937, 0x1193b, 0x1193d, 0x1193e,
        0x1193f, 0x11940, 0x11941, 0x11942, 0x11943, 0x119d1, 0x119d4, 0x119da, 0x119dc, 0x119e0, 0x119e4, 0x11a01,
        0x11a33, 0x11a39, 0x11a3a, 0x11a3b, 0x11a47, 0x11a51, 0x11a57, 0x11a59, 0x11a84, 0x11a8a, 0x11a97, 0x11a98,
        0x11c2f, 0x11c30, 0x11c38, 0x11c3e, 0x11c3f, 0x11c92, 0x11ca9, 0x11caa, 0x11cb1, 0x11cb2, 0x11cb4, 0x11cb5,
        0x11d31, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d46, 0x11d47, 0x11d8a, 0x11d90, 0x11d93, 0x11d95, 0x11d96, 0x11d97,
        0x11ef3, 0x11ef5, 0x11f00, 0x11f02, 0x11f03, 0x11f34, 0x11f36, 0x11f3e, 0x11f40, 0x11f41, 0x11f42, 0x13430,
        0x13440, 0x13447, 0x16af0, 0x16b30, 0x16f4f, 0x16f51, 0x16f8f, 0x16fe4, 0x16ff0, 0x1bc9d, 0x1bca0, 0x1cf00,
        0x1cf30, 0x1d165, 0x1d166, 0x1d167, 0x1d16d, 0x1d16e, 0x1d173, 0x1d17b, 0x1d185, 0x1d1aa, 0x1d242, 0x1da00,
        0x1da3b, 0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e08f, 0x1e130,
        0x1e2ae, 0x1e2ec, 0x1e4ec, 0x1e8d0, 0x1e944, 0x1f1e6, 0x1f3fb, 0xe0000, 0xe0020, 0xe0080, 0xe0100, 0xe01f0},
    {0x100a, 0x4001, 0x1002, 0x1, 0x1012, 0x1021, 0x1001, 0x2070, 0x2007, 0x202d, 0x2001, 0x2002, 0x2002, 0x2001,
        0x7006, 0x200b, 0x1001, 0x2015, 0x2001, 0x2007, 0x7001, 0x2006, 0x2002, 0x2004, 0x7001, 0x2001, 0x201b, 0x200b,
        0x2009, 0x2001, 0x2004, 0x2009, 0x2003, 0x2005, 0x2003, 0x7002, 0x2008, 0x2018, 0x7001, 0x2020, 0x9001, 0x2001,
        0x9001, 0x2001, 0x9003, 0x2008, 0x9004, 0x2001, 0x9002, 0x2007, 0x2002, 0x2001, 0x9002, 0x2001, 0x2001, 0x9002,
        0x2004, 0x9002, 0x9002, 0x2001, 0x2001, 0x2002, 0x2001, 0x2002, 0x9001, 0x2001, 0x9003, 0x2002, 0x2002, 0x2003,
        0x2001, 0x2002, 0x2001, 0x2002, 0x9001, 0x2001, 0x9003, 0x2005, 0x2002, 0x9001, 0x9002, 0x2001, 0x2002, 0x2006,
        0x2001, 0x9002, 0x2001, 0x2002, 0x9001, 0x2004, 0x9002, 0x9002, 0x2001, 0x2003, 0x2002, 0x2001, 0x2001, 0x9001,
        0x2001, 0x9002, 0x9003, 0x9003, 0x2001, 0x2001, 0x2001, 0x9003, 0x2001, 0x2001, 0x2003, 0x9004, 0x2003, 0x2004,
        0x2002, 0x2002, 0x2001, 0x9002, 0x2001, 0x9001, 0x2001, 0x9002, 0x2001, 0x9002, 0x2001, 0x9002, 0x9002, 0x2002,
        0x2002, 0x2002, 0x9001, 0x2002, 0x9002, 0x2002, 0x2001, 0x9002, 0x2004, 0x9003, 0x9003, 0x2001, 0x7001, 0x2001,
        0x2002, 0x2001, 0x9002, 0x2001, 0x2001, 0x9002, 0x2003, 0x2001, 0x9007, 0x2001, 0x9002, 0x2001, 0x9001, 0x2007,
        0x2008, 0x2001, 0x9001, 0x2009, 0x2007, 0x2002, 0x2001, 0x2001, 0x2001, 0x9002, 0x200e, 0x9001, 0x2005, 0x2002,
        0x200b, 0x2024, 0x2001, 0x2004, 0x9001, 0x2006, 0x2002, 0x9002, 0x2002, 0x9002, 0x2002, 0x2003, 0x2004, 0x2001,
        0x9001, 0x2002, 0x2001, 0x2001, 0x3060, 0xb048, 0xa058, 0x2003, 0x2003, 0x9001, 0x2002, 0x9001, 0x2002, 0x2002,
        0x2002, 0x9001, 0x2007, 0x9008, 0x2001, 0x9002, 0x200b, 0x2001, 0x2003, 0x1001, 0x2001, 0x2002, 0x2001, 0x2003,
        0x9004, 0x2002, 0x9003, 0x9002, 0x2001, 0x9006, 0x2003, 0x2002, 0x9002, 0x2001, 0x9001, 0x2001, 0x9001, 0x2007,
        0x2001, 0x2001, 0x2008, 0x9006, 0x200a, 0x2001, 0x201f, 0x2004, 0x9001, 0x2007, 0x9001, 0x2001, 0x9005, 0x2001,
        0x9002, 0x2009, 0x2002, 0x9001, 0x9001, 0x2004, 0x9002, 0x2002, 0x9001, 0x2003, 0x2001, 0x9001, 0x2002, 0x9003,
        0x2001, 0x9001, 0x2003, 0x9002, 0x9008, 0x2008, 0x9002, 0x2002, 0x2003, 0x200d, 0x9001, 0x2007, 0x2001, 0x2001,
        0x9001, 0x2002, 0x2040, 0x1001, 0x2001, 0xc001, 0x1002, 0x1007, 0x1010, 0x2021, 0x2003, 0x2001, 0x2020, 0x2006,
        0x2002, 0x2004, 0x200a, 0x2002, 0x2002, 0x2001, 0x2001, 0x2001, 0x9002, 0x2002, 0x9001, 0x2001, 0x9002, 0x9010,
        0x2002, 0x2012, 0x2001, 0x2008, 0x200b, 0x9002, 0x301d, 0x2003, 0x9001, 0x2001, 0x9002, 0x2004, 0x9002, 0x2002,
        0x9003, 0x2001, 0x2006, 0x9002, 0x2002, 0x9002, 0x2002, 0x2001, 0x2001, 0x9001, 0x2001, 0x2001, 0x2003, 0x2002,
        0x2002, 0x2001, 0x9001, 0x2002, 0x9002, 0x9001, 0x2001, 0x9002, 0x2001, 0x9002, 0x2001, 0x9002, 0x9001, 0x2001,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
        0xb017, 0xa031, 0x2001, 0x2010, 0x2010, 0x1001, 0x2002, 0x100c, 0x2001, 0x2001, 0x2005, 0x2003, 0x2002, 0x2004,
        0x2003, 0x2001, 0x2002, 0x2004, 0x2002, 0x2003, 0x200b, 0x2004, 0x9001, 0x2001, 0x9001, 0x200f, 0x2001, 0x2002,
        0x2003, 0x9001, 0x9003, 0x2004, 0x9002, 0x2002, 0x7001, 0x2001, 0x7001, 0x2003, 0x2005, 0x9001, 0x2008, 0x9002,
        0x2001, 0x2002, 0x9001, 0x9003, 0x2009, 0x9002, 0x7002, 0x2004, 0x9001, 0x2001, 0x9003, 0x2003, 0x9002, 0x2001,
        0x9001, 0x2002, 0x2001, 0x2001, 0x2001, 0x9003, 0x2008, 0x2002, 0x9002, 0x2002, 0x2001, 0x9001, 0x2001, 0x9004,
        0x9002, 0x9003, 0x2001, 0x9002, 0x2007, 0x2005, 0x9003, 0x2008, 0x9002, 0x2003, 0x9001, 0x2001, 0x2001, 0x2001,
        0x9002, 0x2006, 0x9001, 0x2001, 0x9002, 0x2001, 0x9001, 0x2002, 0x9001, 0x2002, 0x2001, 0x9002, 0x2004, 0x9004,
        0x2002, 0x9001, 0x2002, 0x2002, 0x9003, 0x2008, 0x9002, 0x2001, 0x9001, 0x2002, 0x2001, 0x9001, 0x2001, 0x9002,
        0x2006, 0x9001, 0x2001, 0x2003, 0x2004, 0x9001, 0x2005, 0x9003, 0x2009, 0x9001, 0x2002, 0x2001, 0x9005, 0x9002,
        0x2002, 0x9001, 0x2001, 0x7001, 0x9001, 0x7001, 0x9001, 0x2001, 0x9003, 0x2004, 0x2002, 0x9004, 0x2001, 0x9001,
        0x200a, 0x2006, 0x9001, 0x7001, 0x2004, 0x2001, 0x2006, 0x9002, 0x2003, 0x7006, 0x200d, 0x9001, 0x2002, 0x9001,
        0x2007, 0x2006, 0x9001, 0x2001, 0x2016, 0x9001, 0x2007, 0x9001, 0x2002, 0x9001, 0x2002, 0x2006, 0x2001, 0x2002,
        0x2007, 0x7001, 0x2001, 0x9005, 0x2002, 0x9002, 0x2001, 0x9001, 0x2001, 0x2002, 0x9002, 0x2002, 0x7001, 0x9001,
        0x9002, 0x2005, 0x9002, 0x2001, 0x9001, 0x2001, 0x1010, 0x2001, 0x200f, 0x2005, 0x2007, 0x2001, 0x9037, 0x2004,
        0x2001, 0x9002, 0x2002, 0x1004, 0x202e, 0x2017, 0x2001, 0x9001, 0x2003, 0x9001, 0x2005, 0x1008, 0x2008, 0x2007,
        0x2004, 0x2003, 0x2037, 0x2032, 0x2001, 0x2001, 0x2005, 0x200f, 0x2007, 0x2011, 0x2007, 0x2002, 0x2005, 0x2001,
        0x2007, 0x2001, 0x2004, 0x2004, 0x2007, 0x2007, 0x801a, 0x2005, 0x1020, 0x2060, 0x1080, 0x20f0, 0x1e10}};



enum class _Extended_Pictographic_property_values : uint8_t { _Extended_Pictographic_value, _No_value = 255 };



inline constexpr _Unicode_property_data<_Extended_Pictographic_property_values, 78, true>
    _Extended_Pictographic_property_data{
        {0xa9, 0xae, 0x203c, 0x2049, 0x2122, 0x2139, 0x2194, 0x21a9, 0x231a, 0x2328, 0x2388, 0x23cf, 0x23e9, 0x23f8,
            0x24c2, 0x25aa, 0x25b6, 0x25c0, 0x25fb, 0x2600, 0x2607, 0x2614, 0x2690, 0x2708, 0x2714, 0x2716, 0x271d,
            0x2721, 0x2728, 0x2733, 0x2744, 0x2747, 0x274c, 0x274e, 0x2753, 0x2757, 0x2763, 0x2795, 0x27a1, 0x27b0,
            0x27bf, 0x2934, 0x2b05, 0x2b1b, 0x2b50, 0x2b55, 0x3030, 0x303d, 0x3297, 0x3299, 0x1f000, 0x1f10d, 0x1f12f,
            0x1f16c, 0x1f17e, 0x1f18e, 0x1f191, 0x1f1ad, 0x1f201, 0x1f21a, 0x1f22f, 0x1f232, 0x1f23c, 0x1f249, 0x1f400,
            0x1f546, 0x1f680, 0x1f774, 0x1f7d5, 0x1f80c, 0x1f848, 0x1f85a, 0x1f888, 0x1f8ae, 0x1f90c, 0x1f93c, 0x1f947,
            0x1fc00},
        {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x6, 0x2, 0x2, 0x1, 0x1, 0x1, 0xb, 0x3, 0x1, 0x2, 0x1, 0x1, 0x4, 0x6, 0xc, 0x72,
            0x76, 0xb, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x3, 0x1, 0x5, 0x3, 0x1, 0x1, 0x1, 0x2, 0x3,
            0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x100, 0x3, 0x1, 0x6, 0x2, 0x1, 0xa, 0x39, 0xf, 0x1, 0x1, 0x9, 0x4,
            0x1b2, 0x13e, 0x10a, 0x80, 0xc, 0x2b, 0x4, 0x8, 0x6, 0x8, 0x52, 0x2f, 0xa, 0x1b9, 0x3fe}};



enum class __printable_property_values : uint8_t { _Yes_value, _No_value = 255 };



inline constexpr _Unicode_property_data<__printable_property_values, 711, true> __printable_property_data{
    {0x20, 0xa1, 0xae, 0x37a, 0x384, 0x38c, 0x38e, 0x3a3, 0x531, 0x559, 0x58d, 0x591, 0x5d0, 0x5ef, 0x606, 0x61d, 0x6de,
        0x710, 0x74d, 0x7c0, 0x7fd, 0x830, 0x840, 0x85e, 0x860, 0x870, 0x898, 0x8e3, 0x985, 0x98f, 0x993, 0x9aa, 0x9b2,
        0x9b6, 0x9bc, 0x9c7, 0x9cb, 0x9d7, 0x9dc, 0x9df, 0x9e6, 0xa01, 0xa05, 0xa0f, 0xa13, 0xa2a, 0xa32, 0xa35, 0xa38,
        0xa3c, 0xa3e, 0xa47, 0xa4b, 0xa51, 0xa59, 0xa5e, 0xa66, 0xa81, 0xa85, 0xa8f, 0xa93, 0xaaa, 0xab2, 0xab5, 0xabc,
        0xac7, 0xacb, 0xad0, 0xae0, 0xae6, 0xaf9, 0xb01, 0xb05, 0xb0f, 0xb13, 0xb2a, 0xb32, 0xb35, 0xb3c, 0xb47, 0xb4b,
        0xb55, 0xb5c, 0xb5f, 0xb66, 0xb82, 0xb85, 0xb8e, 0xb92, 0xb99, 0xb9c, 0xb9e, 0xba3, 0xba8, 0xbae, 0xbbe, 0xbc6,
        0xbca, 0xbd0, 0xbd7, 0xbe6, 0xc00, 0xc0e, 0xc12, 0xc2a, 0xc3c, 0xc46, 0xc4a, 0xc55, 0xc58, 0xc5d, 0xc60, 0xc66,
        0xc77, 0xc8e, 0xc92, 0xcaa, 0xcb5, 0xcbc, 0xcc6, 0xcca, 0xcd5, 0xcdd, 0xce0, 0xce6, 0xcf1, 0xd00, 0xd0e, 0xd12,
        0xd46, 0xd4a, 0xd54, 0xd66, 0xd81, 0xd85, 0xd9a, 0xdb3, 0xdbd, 0xdc0, 0xdca, 0xdcf, 0xdd6, 0xdd8, 0xde6, 0xdf2,
        0xe01, 0xe3f, 0xe81, 0xe84, 0xe86, 0xe8c, 0xea5, 0xea7, 0xec0, 0xec6, 0xec8, 0xed0, 0xedc, 0xf00, 0xf49, 0xf71,
        0xf99, 0xfbe, 0xfce, 0x1000, 0x10c7, 0x10cd, 0x10d0, 0x124a, 0x1250, 0x1258, 0x125a, 0x1260, 0x128a, 0x1290,
        0x12b2, 0x12b8, 0x12c0, 0x12c2, 0x12c8, 0x12d8, 0x1312, 0x1318, 0x135d, 0x1380, 0x13a0, 0x13f8, 0x1400, 0x1681,
        0x16a0, 0x1700, 0x171f, 0x1740, 0x1760, 0x176e, 0x1772, 0x1780, 0x17e0, 0x17f0, 0x1800, 0x180f, 0x1820, 0x1880,
        0x18b0, 0x1900, 0x1920, 0x1930, 0x1940, 0x1944, 0x1970, 0x1980, 0x19b0, 0x19d0, 0x19de, 0x1a1e, 0x1a60, 0x1a7f,
        0x1a90, 0x1aa0, 0x1ab0, 0x1b00, 0x1b50, 0x1b80, 0x1bfc, 0x1c3b, 0x1c4d, 0x1c90, 0x1cbd, 0x1cd0, 0x1d00, 0x1f18,
        0x1f20, 0x1f48, 0x1f50, 0x1f59, 0x1f5b, 0x1f5d, 0x1f5f, 0x1f80, 0x1fb6, 0x1fc6, 0x1fd6, 0x1fdd, 0x1ff2, 0x1ff6,
        0x2010, 0x2030, 0x2070, 0x2074, 0x2090, 0x20a0, 0x20d0, 0x2100, 0x2190, 0x2440, 0x2460, 0x2b76, 0x2b97, 0x2cf9,
        0x2d27, 0x2d2d, 0x2d30, 0x2d6f, 0x2d7f, 0x2da0, 0x2da8, 0x2db0, 0x2db8, 0x2dc0, 0x2dc8, 0x2dd0, 0x2dd8, 0x2de0,
        0x2e80, 0x2e9b, 0x2f00, 0x2ff0, 0x3001, 0x3041, 0x3099, 0x3105, 0x3131, 0x3190, 0x31f0, 0x3220, 0xa490, 0xa4d0,
        0xa640, 0xa700, 0xa7d0, 0xa7d3, 0xa7d5, 0xa7f2, 0xa830, 0xa840, 0xa880, 0xa8ce, 0xa8e0, 0xa95f, 0xa980, 0xa9cf,
        0xa9de, 0xaa00, 0xaa40, 0xaa50, 0xaa5c, 0xaadb, 0xab01, 0xab09, 0xab11, 0xab20, 0xab28, 0xab30, 0xab70, 0xabf0,
        0xac00, 0xd7b0, 0xd7cb, 0xf900, 0xfa70, 0xfb00, 0xfb13, 0xfb1d, 0xfb38, 0xfb3e, 0xfb40, 0xfb43, 0xfb46, 0xfbd3,
        0xfd92, 0xfdcf, 0xfdf0, 0xfe20, 0xfe54, 0xfe68, 0xfe70, 0xfe76, 0xff01, 0xffc2, 0xffca, 0xffd2, 0xffda, 0xffe0,
        0xffe8, 0xfffc, 0x10000, 0x1000d, 0x10028, 0x1003c, 0x1003f, 0x10050, 0x10080, 0x10100, 0x10107, 0x10137,
        0x10190, 0x101a0, 0x101d0, 0x10280, 0x102a0, 0x102e0, 0x10300, 0x1032d, 0x10350, 0x10380, 0x1039f, 0x103c8,
        0x10400, 0x104a0, 0x104b0, 0x104d8, 0x10500, 0x10530, 0x1056f, 0x1057c, 0x1058c, 0x10594, 0x10597, 0x105a3,
        0x105b3, 0x105bb, 0x10600, 0x10740, 0x10760, 0x10780, 0x10787, 0x107b2, 0x10800, 0x10808, 0x1080a, 0x10837,
        0x1083c, 0x1083f, 0x10857, 0x108a7, 0x108e0, 0x108f4, 0x108fb, 0x1091f, 0x1093f, 0x10980, 0x109bc, 0x109d2,
        0x10a05, 0x10a0c, 0x10a15, 0x10a19, 0x10a38, 0x10a3f, 0x10a50, 0x10a60, 0x10ac0, 0x10aeb, 0x10b00, 0x10b39,
        0x10b58, 0x10b78, 0x10b99, 0x10ba9, 0x10c00, 0x10c80, 0x10cc0, 0x10cfa, 0x10d30, 0x10e60, 0x10e80, 0x10eab,
        0x10eb0, 0x10efd, 0x10f30, 0x10f70, 0x10fb0, 0x10fe0, 0x11000, 0x11052, 0x1107f, 0x110be, 0x110d0, 0x110f0,
        0x11100, 0x11136, 0x11150, 0x11180, 0x111e1, 0x11200, 0x11213, 0x11280, 0x11288, 0x1128a, 0x1128f, 0x1129f,
        0x112b0, 0x112f0, 0x11300, 0x11305, 0x1130f, 0x11313, 0x1132a, 0x11332, 0x11335, 0x1133b, 0x11347, 0x1134b,
        0x11350, 0x11357, 0x1135d, 0x11366, 0x11370, 0x11400, 0x1145d, 0x11480, 0x114d0, 0x11580, 0x115b8, 0x11600,
        0x11650, 0x11660, 0x11680, 0x116c0, 0x11700, 0x1171d, 0x11730, 0x11800, 0x118a0, 0x118ff, 0x11909, 0x1190c,
        0x11915, 0x11918, 0x11937, 0x1193b, 0x11950, 0x119a0, 0x119aa, 0x119da, 0x11a00, 0x11a50, 0x11ab0, 0x11b00,
        0x11c00, 0x11c0a, 0x11c38, 0x11c50, 0x11c70, 0x11c92, 0x11ca9, 0x11d00, 0x11d08, 0x11d0b, 0x11d3a, 0x11d3c,
        0x11d3f, 0x11d50, 0x11d60, 0x11d67, 0x11d6a, 0x11d90, 0x11d93, 0x11da0, 0x11ee0, 0x11f00, 0x11f12, 0x11f3e,
        0x11fb0, 0x11fc0, 0x11fff, 0x12400, 0x12470, 0x12480, 0x12f90, 0x13000, 0x13440, 0x14400, 0x16800, 0x16a40,
        0x16a60, 0x16a6e, 0x16ac0, 0x16ad0, 0x16af0, 0x16b00, 0x16b50, 0x16b5b, 0x16b63, 0x16b7d, 0x16e40, 0x16f00,
        0x16f4f, 0x16f8f, 0x16fe0, 0x16ff0, 0x17000, 0x18800, 0x18d00, 0x1aff0, 0x1aff5, 0x1affd, 0x1b000, 0x1b132,
        0x1b150, 0x1b155, 0x1b164, 0x1b170, 0x1bc00, 0x1bc70, 0x1bc80, 0x1bc90, 0x1bc9c, 0x1cf00, 0x1cf30, 0x1cf50,
        0x1d000, 0x1d100, 0x1d129, 0x1d17b, 0x1d200, 0x1d2c0, 0x1d2e0, 0x1d300, 0x1d360, 0x1d400, 0x1d456, 0x1d49e,
        0x1d4a2, 0x1d4a5, 0x1d4a9, 0x1d4ae, 0x1d4bb, 0x1d4bd, 0x1d4c5, 0x1d507, 0x1d50d, 0x1d516, 0x1d51e, 0x1d53b,
        0x1d540, 0x1d546, 0x1d54a, 0x1d552, 0x1d6a8, 0x1d7ce, 0x1da9b, 0x1daa1, 0x1df00, 0x1df25, 0x1e000, 0x1e008,
        0x1e01b, 0x1e023, 0x1e026, 0x1e030, 0x1e08f, 0x1e100, 0x1e130, 0x1e140, 0x1e14e, 0x1e290, 0x1e2c0, 0x1e2ff,
        0x1e4d0, 0x1e7e0, 0x1e7e8, 0x1e7ed, 0x1e7f0, 0x1e800, 0x1e8c7, 0x1e900, 0x1e950, 0x1e95e, 0x1ec71, 0x1ed01,
        0x1ee00, 0x1ee05, 0x1ee21, 0x1ee24, 0x1ee27, 0x1ee29, 0x1ee34, 0x1ee39, 0x1ee3b, 0x1ee42, 0x1ee47, 0x1ee49,
        0x1ee4b, 0x1ee4d, 0x1ee51, 0x1ee54, 0x1ee57, 0x1ee59, 0x1ee5b, 0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee64, 0x1ee67,
        0x1ee6c, 0x1ee74, 0x1ee79, 0x1ee7e, 0x1ee80, 0x1ee8b, 0x1eea1, 0x1eea5, 0x1eeab, 0x1eef0, 0x1f000, 0x1f030,
        0x1f0a0, 0x1f0b1, 0x1f0c1, 0x1f0d1, 0x1f100, 0x1f1e6, 0x1f210, 0x1f240, 0x1f250, 0x1f260, 0x1f300, 0x1f6dc,
        0x1f6f0, 0x1f700, 0x1f77b, 0x1f7e0, 0x1f7f0, 0x1f800, 0x1f810, 0x1f850, 0x1f860, 0x1f890, 0x1f8b0, 0x1f900,
        0x1fa60, 0x1fa70, 0x1fa80, 0x1fa90, 0x1fabf, 0x1face, 0x1fae0, 0x1faf0, 0x1fb00, 0x1fb94, 0x1fbf0, 0x20000,
        0x2a700, 0x2b740, 0x2b820, 0x2ceb0, 0x2f800, 0x30000, 0x31350, 0xe0100},
    {0x5f, 0xc, 0x2ca, 0x6, 0x7, 0x1, 0x14, 0x18d, 0x26, 0x32, 0x3, 0x37, 0x1b, 0x6, 0x16, 0xc0, 0x30, 0x3b, 0x65, 0x3b,
        0x31, 0xf, 0x1c, 0x1, 0xb, 0x1f, 0x4a, 0xa1, 0x8, 0x2, 0x16, 0x7, 0x1, 0x4, 0x9, 0x2, 0x4, 0x1, 0x2, 0x5, 0x19,
        0x3, 0x6, 0x2, 0x16, 0x7, 0x2, 0x2, 0x2, 0x1, 0x5, 0x2, 0x3, 0x1, 0x4, 0x1, 0x11, 0x3, 0x9, 0x3, 0x16, 0x7, 0x2,
        0x5, 0xa, 0x3, 0x3, 0x1, 0x4, 0xc, 0x7, 0x3, 0x8, 0x2, 0x16, 0x7, 0x2, 0x5, 0x9, 0x2, 0x3, 0x3, 0x2, 0x5, 0x12,
        0x2, 0x6, 0x3, 0x4, 0x2, 0x1, 0x2, 0x2, 0x3, 0xc, 0x5, 0x3, 0x4, 0x1, 0x1, 0x15, 0xd, 0x3, 0x17, 0x10, 0x9, 0x3,
        0x4, 0x2, 0x3, 0x1, 0x4, 0xa, 0x16, 0x3, 0x17, 0xa, 0x5, 0x9, 0x3, 0x4, 0x2, 0x2, 0x4, 0xa, 0x3, 0xd, 0x3, 0x33,
        0x3, 0x6, 0x10, 0x1a, 0x3, 0x12, 0x18, 0x9, 0x1, 0x7, 0x1, 0x6, 0x1, 0x8, 0xa, 0x3, 0x3a, 0x1d, 0x2, 0x1, 0x5,
        0x18, 0x1, 0x17, 0x5, 0x1, 0x7, 0xa, 0x4, 0x48, 0x24, 0x27, 0x24, 0xf, 0xd, 0xc6, 0x1, 0x1, 0x179, 0x4, 0x7,
        0x1, 0x4, 0x29, 0x4, 0x21, 0x4, 0x7, 0x1, 0x4, 0xf, 0x39, 0x4, 0x43, 0x20, 0x1a, 0x56, 0x6, 0x280, 0x1c, 0x59,
        0x16, 0x18, 0x14, 0xd, 0x3, 0x2, 0x5e, 0xa, 0xa, 0xe, 0xb, 0x59, 0x2b, 0x46, 0x1f, 0xc, 0xc, 0x1, 0x2a, 0x5,
        0x2c, 0x1a, 0xb, 0x3e, 0x41, 0x1d, 0xb, 0xa, 0xe, 0x1f, 0x4d, 0x2f, 0x74, 0x3c, 0xf, 0x3c, 0x2b, 0xb, 0x2b,
        0x216, 0x6, 0x26, 0x6, 0x8, 0x1, 0x1, 0x1, 0x1f, 0x35, 0xf, 0xe, 0x6, 0x13, 0x3, 0x9, 0x18, 0x2f, 0x2, 0x1b,
        0xd, 0x21, 0x21, 0x8c, 0x297, 0xb, 0x714, 0x20, 0x15d, 0x2d, 0x1, 0x1, 0x38, 0x2, 0x18, 0x7, 0x7, 0x7, 0x7, 0x7,
        0x7, 0x7, 0x7, 0x7e, 0x1a, 0x59, 0xd6, 0xc, 0x3f, 0x56, 0x67, 0x2b, 0x5e, 0x54, 0x2f, 0x726d, 0x37, 0x15c, 0xb8,
        0xcb, 0x2, 0x1, 0x5, 0x3b, 0xa, 0x38, 0x46, 0xc, 0x74, 0x1e, 0x4e, 0xb, 0x21, 0x37, 0xe, 0xa, 0x67, 0x1c, 0x6,
        0x6, 0x6, 0x7, 0x7, 0x3c, 0x7e, 0xa, 0x2ba4, 0x17, 0x31, 0x16e, 0x6a, 0x7, 0x5, 0x1a, 0x5, 0x1, 0x2, 0x2, 0x7d,
        0x1bd, 0x36, 0x1, 0x2a, 0x33, 0x13, 0x4, 0x5, 0x87, 0xbe, 0x6, 0x6, 0x6, 0x3, 0x7, 0x7, 0x2, 0xc, 0x1a, 0x13,
        0x2, 0xf, 0xe, 0x7b, 0x3, 0x2d, 0x58, 0xd, 0x1, 0x2e, 0x1d, 0x31, 0x1c, 0x24, 0x1e, 0x2b, 0x1e, 0x25, 0xe, 0x9e,
        0xa, 0x24, 0x24, 0x28, 0x34, 0xc, 0xf, 0x7, 0x2, 0xb, 0xf, 0x7, 0x2, 0x137, 0x16, 0x8, 0x6, 0x2a, 0x9, 0x6, 0x1,
        0x2c, 0x2, 0x1, 0x17, 0x48, 0x9, 0x13, 0x2, 0x21, 0x1b, 0x1, 0x38, 0x14, 0x32, 0x2, 0x8, 0x3, 0x1d, 0x3, 0xa,
        0x9, 0x40, 0x27, 0xc, 0x36, 0x1d, 0x1b, 0x1a, 0x4, 0x7, 0x49, 0x33, 0x33, 0x2e, 0xa, 0x1f, 0x2a, 0x3, 0x2, 0x2b,
        0x2a, 0x1a, 0x1c, 0x17, 0x4e, 0x24, 0x3e, 0x5, 0x19, 0xa, 0x35, 0x12, 0x27, 0x60, 0x14, 0x12, 0x2f, 0x7, 0x1,
        0x4, 0xf, 0xb, 0x3b, 0xa, 0x4, 0x8, 0x2, 0x16, 0x7, 0x2, 0x5, 0xa, 0x2, 0x3, 0x1, 0x1, 0x7, 0x7, 0x5, 0x5c, 0x5,
        0x48, 0xa, 0x36, 0x26, 0x45, 0xa, 0xd, 0x3a, 0xa, 0x1b, 0xf, 0x17, 0x3c, 0x53, 0x8, 0x1, 0x8, 0x2, 0x1e, 0x2,
        0xc, 0xa, 0x8, 0x2e, 0xb, 0x48, 0x53, 0x49, 0xa, 0x9, 0x2d, 0xe, 0x1d, 0x20, 0x16, 0xe, 0x7, 0x2, 0x2c, 0x1,
        0x2, 0x9, 0xa, 0x6, 0x2, 0x25, 0x2, 0x6, 0xa, 0x19, 0x11, 0x29, 0x1c, 0x1, 0x32, 0x39b, 0x6f, 0x5, 0xc4, 0x63,
        0x430, 0x16, 0x247, 0x239, 0x1f, 0xa, 0x51, 0xa, 0x1e, 0x6, 0x46, 0xa, 0x7, 0x15, 0x13, 0x5b, 0x4b, 0x39, 0x11,
        0x5, 0x2, 0x17f8, 0x4d6, 0x9, 0x4, 0x7, 0x2, 0x123, 0x1, 0x3, 0x1, 0x4, 0x18c, 0x6b, 0xd, 0x9, 0xa, 0x4, 0x2e,
        0x17, 0x74, 0xf6, 0x27, 0x4a, 0x70, 0x46, 0x14, 0x14, 0x57, 0x19, 0x55, 0x47, 0x2, 0x1, 0x2, 0x4, 0xc, 0x1, 0x7,
        0x41, 0x4, 0x8, 0x7, 0x1c, 0x4, 0x5, 0x1, 0x7, 0x154, 0x124, 0x2be, 0x5, 0xf, 0x1f, 0x6, 0x7, 0x11, 0x7, 0x2,
        0x5, 0x3e, 0x1, 0x2d, 0xe, 0xa, 0x2, 0x1f, 0x3a, 0x1, 0x2a, 0x7, 0x4, 0x2, 0xf, 0xc5, 0x10, 0x4c, 0xa, 0x2,
        0x44, 0x3d, 0x4, 0x1b, 0x2, 0x1, 0x1, 0xa, 0x4, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1,
        0x1, 0x2, 0x1, 0x4, 0x7, 0x4, 0x4, 0x1, 0xa, 0x11, 0x3, 0x5, 0x11, 0x2, 0x2c, 0x64, 0xf, 0xf, 0xf, 0x25, 0xae,
        0x1d, 0x2c, 0x9, 0x2, 0x6, 0x3d8, 0x11, 0xd, 0x77, 0x5f, 0xc, 0x1, 0xc, 0x38, 0xa, 0x28, 0x1e, 0x2, 0x154, 0xe,
        0xd, 0x9, 0x2e, 0x7, 0xe, 0x9, 0x9, 0x93, 0x37, 0xa, 0xa6e0, 0x103a, 0xde, 0x1682, 0x1d31, 0x21e, 0x134b,
        0x1060, 0xf0}};



enum class _Grapheme_Extend_property_values : uint8_t { _Grapheme_Extend_value, _No_value = 255 };



inline constexpr _Unicode_property_data<_Grapheme_Extend_property_values, 363, true> _Grapheme_Extend_property_data{
    {0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x610, 0x64b, 0x670, 0x6d6, 0x6df, 0x6e7, 0x6ea, 0x711, 0x730,
        0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829, 0x859, 0x898, 0x8ca, 0x8e3, 0x93a, 0x93c, 0x941, 0x94d, 0x951,
        0x962, 0x981, 0x9bc, 0x9be, 0x9c1, 0x9cd, 0x9d7, 0x9e2, 0x9fe, 0xa01, 0xa3c, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70,
        0xa75, 0xa81, 0xabc, 0xac1, 0xac7, 0xacd, 0xae2, 0xafa, 0xb01, 0xb3c, 0xb3e, 0xb41, 0xb4d, 0xb55, 0xb62, 0xb82,
        0xbbe, 0xbc0, 0xbcd, 0xbd7, 0xc00, 0xc04, 0xc3c, 0xc3e, 0xc46, 0xc4a, 0xc55, 0xc62, 0xc81, 0xcbc, 0xcbf, 0xcc2,
        0xcc6, 0xccc, 0xcd5, 0xce2, 0xd00, 0xd3b, 0xd3e, 0xd41, 0xd4d, 0xd57, 0xd62, 0xd81, 0xdca, 0xdcf, 0xdd2, 0xdd6,
        0xddf, 0xe31, 0xe34, 0xe47, 0xeb1, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37, 0xf39, 0xf71, 0xf80, 0xf86, 0xf8d, 0xf99,
        0xfc6, 0x102d, 0x1032, 0x1039, 0x103d, 0x1058, 0x105e, 0x1071, 0x1082, 0x1085, 0x108d, 0x109d, 0x135d, 0x1712,
        0x1732, 0x1752, 0x1772, 0x17b4, 0x17b7, 0x17c6, 0x17c9, 0x17dd, 0x180b, 0x180f, 0x1885, 0x18a9, 0x1920, 0x1927,
        0x1932, 0x1939, 0x1a17, 0x1a1b, 0x1a56, 0x1a58, 0x1a60, 0x1a62, 0x1a65, 0x1a73, 0x1a7f, 0x1ab0, 0x1b00, 0x1b34,
        0x1b3c, 0x1b42, 0x1b6b, 0x1b80, 0x1ba2, 0x1ba8, 0x1bab, 0x1be6, 0x1be8, 0x1bed, 0x1bef, 0x1c2c, 0x1c36, 0x1cd0,
        0x1cd4, 0x1ce2, 0x1ced, 0x1cf4, 0x1cf8, 0x1dc0, 0x200c, 0x20d0, 0x2cef, 0x2d7f, 0x2de0, 0x302a, 0x3099, 0xa66f,
        0xa674, 0xa69e, 0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa825, 0xa82c, 0xa8c4, 0xa8e0, 0xa8ff, 0xa926, 0xa947, 0xa980,
        0xa9b3, 0xa9b6, 0xa9bc, 0xa9e5, 0xaa29, 0xaa31, 0xaa35, 0xaa43, 0xaa4c, 0xaa7c, 0xaab0, 0xaab2, 0xaab7, 0xaabe,
        0xaac1, 0xaaec, 0xaaf6, 0xabe5, 0xabe8, 0xabed, 0xfb1e, 0xfe00, 0xfe20, 0xff9e, 0x101fd, 0x102e0, 0x10376,
        0x10a01, 0x10a05, 0x10a0c, 0x10a38, 0x10a3f, 0x10ae5, 0x10d24, 0x10eab, 0x10efd, 0x10f46, 0x10f82, 0x11001,
        0x11038, 0x11070, 0x11073, 0x1107f, 0x110b3, 0x110b9, 0x110c2, 0x11100, 0x11127, 0x1112d, 0x11173, 0x11180,
        0x111b6, 0x111c9, 0x111cf, 0x1122f, 0x11234, 0x11236, 0x1123e, 0x11241, 0x112df, 0x112e3, 0x11300, 0x1133b,
        0x1133e, 0x11340, 0x11357, 0x11366, 0x11370, 0x11438, 0x11442, 0x11446, 0x1145e, 0x114b0, 0x114b3, 0x114ba,
        0x114bd, 0x114bf, 0x114c2, 0x115af, 0x115b2, 0x115bc, 0x115bf, 0x115dc, 0x11633, 0x1163d, 0x1163f, 0x116ab,
        0x116ad, 0x116b0, 0x116b7, 0x1171d, 0x11722, 0x11727, 0x1182f, 0x11839, 0x11930, 0x1193b, 0x1193e, 0x11943,
        0x119d4, 0x119da, 0x119e0, 0x11a01, 0x11a33, 0x11a3b, 0x11a47, 0x11a51, 0x11a59, 0x11a8a, 0x11a98, 0x11c30,
        0x11c38, 0x11c3f, 0x11c92, 0x11caa, 0x11cb2, 0x11cb5, 0x11d31, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d47, 0x11d90,
        0x11d95, 0x11d97, 0x11ef3, 0x11f00, 0x11f36, 0x11f40, 0x11f42, 0x13440, 0x13447, 0x16af0, 0x16b30, 0x16f4f,
        0x16f8f, 0x16fe4, 0x1bc9d, 0x1cf00, 0x1cf30, 0x1d165, 0x1d167, 0x1d16e, 0x1d17b, 0x1d185, 0x1d1aa, 0x1d242,
        0x1da00, 0x1da3b, 0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e08f,
        0x1e130, 0x1e2ae, 0x1e2ec, 0x1e4ec, 0x1e8d0, 0x1e944, 0xe0020, 0xe0100},
    {0x70, 0x7, 0x2d, 0x1, 0x2, 0x2, 0x1, 0xb, 0x15, 0x1, 0x7, 0x6, 0x2, 0x4, 0x1, 0x1b, 0xb, 0x9, 0x1, 0x4, 0x9, 0x3,
        0x5, 0x3, 0x8, 0x18, 0x20, 0x1, 0x1, 0x8, 0x1, 0x7, 0x2, 0x1, 0x1, 0x1, 0x4, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2,
        0x2, 0x3, 0x1, 0x2, 0x1, 0x2, 0x1, 0x5, 0x2, 0x1, 0x2, 0x6, 0x1, 0x1, 0x2, 0x4, 0x1, 0x3, 0x2, 0x1, 0x1, 0x1,
        0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x3, 0x4, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x4,
        0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x3, 0x1, 0x1, 0x1, 0x7, 0x8, 0x1, 0x9, 0x7, 0x2, 0x1, 0x1, 0x1, 0xe, 0x5, 0x2,
        0xb, 0x24, 0x1, 0x4, 0x6, 0x2, 0x2, 0x2, 0x3, 0x4, 0x1, 0x2, 0x1, 0x1, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7, 0x1,
        0xb, 0x1, 0x3, 0x1, 0x2, 0x1, 0x3, 0x2, 0x1, 0x3, 0x2, 0x1, 0x1, 0x7, 0x1, 0x1, 0x8, 0xa, 0x1, 0x1f, 0x4, 0x7,
        0x1, 0x1, 0x9, 0x2, 0x4, 0x2, 0x3, 0x1, 0x2, 0x1, 0x3, 0x8, 0x2, 0x3, 0xd, 0x7, 0x1, 0x1, 0x2, 0x40, 0x1, 0x21,
        0x3, 0x1, 0x20, 0x6, 0x2, 0x4, 0xa, 0x2, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x2, 0x12, 0x1, 0x8, 0xb, 0x3, 0x1, 0x4,
        0x2, 0x1, 0x6, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x3, 0x2, 0x2, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x10, 0x10, 0x2,
        0x1, 0x1, 0x5, 0x3, 0x2, 0x4, 0x3, 0x1, 0x2, 0x4, 0x2, 0x3, 0xb, 0x4, 0x1, 0xf, 0x1, 0x2, 0x3, 0x4, 0x2, 0x1,
        0x3, 0x5, 0x8, 0x1, 0x2, 0x9, 0x4, 0x1, 0x3, 0x1, 0x2, 0x1, 0x1, 0x1, 0x8, 0x2, 0x2, 0x1, 0x1, 0x1, 0x7, 0x5,
        0x8, 0x3, 0x1, 0x1, 0x1, 0x6, 0x1, 0x1, 0x2, 0x2, 0x1, 0x4, 0x2, 0x2, 0x2, 0x8, 0x1, 0x2, 0x1, 0x1, 0x6, 0x1,
        0x3, 0x4, 0x5, 0x9, 0x2, 0x1, 0x2, 0x1, 0x1, 0x4, 0x2, 0x1, 0xa, 0x6, 0x4, 0x1, 0x6, 0x3, 0xd, 0x2, 0x7, 0x6,
        0x1, 0x16, 0x7, 0x2, 0x2, 0x6, 0x1, 0x2, 0x7, 0x1, 0x2, 0x1, 0x1, 0x2, 0x2, 0x5, 0x1, 0x1, 0x1, 0xf, 0x5, 0x7,
        0x1, 0x4, 0x1, 0x2, 0x2e, 0x17, 0x1, 0x3, 0x5, 0x8, 0x7, 0x4, 0x3, 0x37, 0x32, 0x1, 0x1, 0x5, 0xf, 0x7, 0x11,
        0x7, 0x2, 0x5, 0x1, 0x7, 0x1, 0x4, 0x4, 0x7, 0x7, 0x60, 0xf0}};

}



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

#line 533 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_format_ucd_tables.hpp"
#line 534 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_format_ucd_tables.hpp"
#pragma external_header(pop)
#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_print.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" {

enum class __std_unicode_console_handle : intptr_t { _Invalid = -1 };

struct __std_unicode_console_retrieval_result {
    __std_unicode_console_handle _Console_handle;

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    __std_win_error _Error;
};

[[nodiscard]]   __std_unicode_console_retrieval_result
    __stdcall __std_get_unicode_console_handle_from_file_stream(  FILE* _Stream) noexcept;

[[nodiscard]]   __std_win_error
    __stdcall __std_print_to_unicode_console(  __std_unicode_console_handle _Console_handle,
          const char* _Str,   size_t _Str_size) noexcept;

}

namespace std {

[[nodiscard]] consteval bool _Is_ordinary_literal_encoding_utf8() {
    

    return true;


#line 66 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_print.hpp"
}

}



#pragma warning(pop)
#pragma pack(pop)
#line 75 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_print.hpp"
#line 76 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\__msvc_print.hpp"
#pragma external_header(pop)
#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bit"





#pragma once






#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
}










































#line 80 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bit"

 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 = _Unsigned_integer_digits<_Ty> - ::std:: countl_zero(static_cast<_Ty>(_Val - 1));

    if constexpr (sizeof(_Ty) < sizeof(unsigned int)) { 
        if (::std:: is_constant_evaluated()) {
            
            
            
            
            
            
            
            
            
            if (_Num == _Unsigned_integer_digits<_Ty>) {
                _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} << (_Unsigned_integer_digits<_Ty> - 1 - ::std:: countl_zero(_Val)));
}

 template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int bit_width(const _Ty _Val) noexcept {
    return _Unsigned_integer_digits<_Ty> - ::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 = _Unsigned_integer_digits<_Ty>;

    if (!::std:: is_constant_evaluated()) {
        if constexpr (_Digits == 64) {
            return _rotl64(_Val, _Rotation);
        } else if constexpr (_Digits == 32) {
            return _rotl(_Val, _Rotation);
        } else if constexpr (_Digits == 16) {
            return _rotl16(_Val, static_cast<unsigned char>(_Rotation));
        } else {
            ;
            return _rotl8(_Val, static_cast<unsigned char>(_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> >
[[nodiscard]] constexpr _Ty rotr(const _Ty _Val, const int _Rotation) noexcept {
    constexpr auto _Digits = _Unsigned_integer_digits<_Ty>;

    if (!::std:: is_constant_evaluated()) {
        if constexpr (_Digits == 64) {
            return _rotr64(_Val, _Rotation);
        } else if constexpr (_Digits == 32) {
            return _rotr(_Val, _Rotation);
        } else if constexpr (_Digits == 16) {
            return _rotr16(_Val, static_cast<unsigned char>(_Rotation));
        } else {
            ;
            return _rotr8(_Val, static_cast<unsigned char>(_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);
    }
}

 template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> >
[[nodiscard]] constexpr int countl_zero(const _Ty _Val) noexcept {


    if (!::std:: is_constant_evaluated()) {
        return _Checked_x86_x64_countl_zero(_Val);
    }




#line 204 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bit"
#line 205 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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> = 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);
}

 enum class endian { little = 0, big = 1, native = little };

}


#pragma warning(pop)
#pragma pack(pop)
#line 237 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bit"
#line 238 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bit"
#line 239 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bit"
#pragma external_header(pop)
#line 49 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv.h"





#pragma once











#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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)); }

 struct to_chars_result {
    char* ptr;
    errc ec;

    [[nodiscard]] friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
#line 43 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv.h"
};

}



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

#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv.h"
#line 54 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv.h"
#pragma external_header(pop)
#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"


































#pragma once









#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu_tables.h"


































#pragma once









#line 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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'
};






extern const uint64_t __DOUBLE_POW5_INV_SPLIT[292][2];

extern const uint64_t __DOUBLE_POW5_SPLIT[326][2];





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
};

extern const uint64_t __POW10_SPLIT[1224][3];

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
};

extern const uint64_t __POW10_SPLIT_2[3133][3];





}



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

#line 158 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu_tables.h"
#line 159 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu_tables.h"
#pragma external_header(pop)
#line 46 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"






#line 53 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"



#line 57 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"



#line 61 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;







[[nodiscard]] inline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {
  return _umul128(__a, __b, __productHi);
}

[[nodiscard]] inline uint64_t __ryu_shiftright128(const uint64_t __lo, const uint64_t __hi, const uint32_t __dist) {
  
  
  
  
  
  
  
  ;
  return __shiftright128(__lo, __hi, static_cast<unsigned char>(__dist));
}















































#line 211 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"




























































[[nodiscard]] inline uint64_t __div5(const uint64_t __x) {
  return __x / 5;
}

[[nodiscard]] inline uint64_t __div10(const uint64_t __x) {
  return __x / 10;
}

[[nodiscard]] inline uint64_t __div100(const uint64_t __x) {
  return __x / 100;
}

[[nodiscard]] inline uint64_t __div1e8(const uint64_t __x) {
  return __x / 100000000;
}

[[nodiscard]] inline uint64_t __div1e9(const uint64_t __x) {
  return __x / 1000000000;
}

[[nodiscard]] inline uint32_t __mod1e9(const uint64_t __x) {
  return static_cast<uint32_t>(__x - 1000000000 * __div1e9(__x));
}

#line 296 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;



[[nodiscard]] inline uint64_t __umul256_hi128_lo64(
  const uint64_t __aHi, const uint64_t __aLo, const uint64_t __bHi, const uint64_t __bLo) {
  uint64_t __b00Hi;
  const uint64_t __b00Lo = __ryu_umul128(__aLo, __bLo, &__b00Hi);
  uint64_t __b01Hi;
  const uint64_t __b01Lo = __ryu_umul128(__aLo, __bHi, &__b01Hi);
  uint64_t __b10Hi;
  const uint64_t __b10Lo = __ryu_umul128(__aHi, __bLo, &__b10Hi);
  uint64_t __b11Hi;
  const uint64_t __b11Lo = __ryu_umul128(__aHi, __bHi, &__b11Hi);
  (void) __b00Lo; 
  (void) __b11Hi; 
  const uint64_t __temp1Lo = __b10Lo + __b00Hi;
  const uint64_t __temp1Hi = __b10Hi + (__temp1Lo < __b10Lo);
  const uint64_t __temp2Lo = __b01Lo + __temp1Lo;
  const uint64_t __temp2Hi = __b01Hi + (__temp2Lo < __b01Lo);
  return __b11Lo + __temp1Hi + __temp2Hi;
}

[[nodiscard]] inline uint32_t __uint128_mod1e9(const uint64_t __vHi, const uint64_t __vLo) {
  
  
  const uint64_t __multiplied = __umul256_hi128_lo64(__vHi, __vLo, 0x89705F4136B4A597u, 0x31680A88F8953031u);

  
  const uint32_t __shifted = static_cast<uint32_t>(__multiplied >> 29);

  return static_cast<uint32_t>(__vLo) - 1000000000 * __shifted;
}
#line 364 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;         
  ;
  ;

  const uint32_t __dist = static_cast<uint32_t>(__j - 128); 
  const uint64_t __shiftedhigh = __s1high >> __dist;
  const uint64_t __shiftedlow = __ryu_shiftright128(__s1low, __s1high, __dist);
  return __uint128_mod1e9(__shiftedhigh, __shiftedlow);











#line 398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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] = static_cast<char>(__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 uint64_t __sum = (__bits0 >> 32) + __bits1;
  const uint64_t __shiftedSum = __sum >> (__shift - 32);
  ;
  return static_cast<uint32_t>(__shiftedSum);
#line 1036 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
  const 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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
}












































[[nodiscard]] inline uint64_t __mulShift(const uint64_t __m, const uint64_t* const __mul, const int32_t __j) {
  
  uint64_t __high1;                                               
  const uint64_t __low1 = __ryu_umul128(__m, __mul[1], &__high1); 
  uint64_t __high0;                                               
  (void) __ryu_umul128(__m, __mul[0], &__high0);                  
  const uint64_t __sum = __high0 + __low1;
  if (__sum < __high0) {
    ++__high1; 
  }
  return __ryu_shiftright128(__sum, __high1, static_cast<uint32_t>(__j - 64));
}

[[nodiscard]] inline uint64_t __mulShiftAll(const uint64_t __m, const uint64_t* const __mul, const int32_t __j,
  uint64_t* const __vp, uint64_t* const __vm, const uint32_t __mmShift) {
  *__vp = __mulShift(4 * __m + 2, __mul, __j);
  *__vm = __mulShift(4 * __m - 1 - __mmShift, __mul, __j);
  return __mulShift(4 * __m, __mul, __j);
}




































#line 1720 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
  const 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;

        (void) _BitScanForward64(&_Trailing_zero_bits, __v.__mantissa); 









#line 2063 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"
#line 2424 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_ryu.h"
#pragma external_header(pop)
#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_tables.h"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_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 _Floating>
struct _General_precision_tables_2;

template <>
struct _General_precision_tables_2<float> {
    static constexpr int _Max_special_P = 7;

    static const uint32_t _Special_X_table[63];

    static constexpr int _Max_P = 39;

    static const uint32_t _Ordinary_X_table[44];
};

template <>
struct _General_precision_tables_2<double> {
    static constexpr int _Max_special_P = 15;

    static const uint64_t _Special_X_table[195];

    static constexpr int _Max_P = 309;

    static const uint64_t _Ordinary_X_table[314];
};

}



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

#line 114 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_tables.h"
#line 115 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xcharconv_tables.h"
#pragma external_header(pop)
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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'};
;

template <class _RawTy>
[[nodiscard]] inline to_chars_result _Integer_to_chars(
    char* _First, char* const _Last, const _RawTy _Raw_value, const int _Base) noexcept {
    _Adl_verify_range(_First, _Last);
    do { if (_Base >= 2 && _Base <= 36) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 42, 0, "%s", "invalid base in to_chars()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid base in to_chars()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 42, 0); } while (false); } ; } while (false);

    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};
    }

    _Copy_n_unchecked4(_RNext, _Digits_written, _First);

    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 214 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"
};


inline 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};
;

[[nodiscard]] inline unsigned char _Digit_from_char(const char _Ch) noexcept {
    
    return _Digit_from_byte[static_cast<unsigned char>(_Ch)];
}

template <class _RawTy>
[[nodiscard]] inline 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);
    do { if (_Base >= 2 && _Base <= 36) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 239, 0, "%s", "invalid base in from_chars()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid base in from_chars()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 239, 0); } while (false); } ; } while (false);

    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);
#pragma warning(push)
#pragma warning(disable : 26450) 
    constexpr _Unsigned _Abs_int_min = static_cast<_Unsigned>(_Int_max + 1);
#pragma warning(pop)

    _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 {
#pragma warning(push)
#pragma warning(disable : 26495) 
                                 
    _Big_integer_flt() noexcept : _Myused(0) {}
#pragma warning(pop)

    _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;
}

extern const uint32_t _Large_power_data[578];



[[nodiscard]] inline bool _Multiply_by_power_of_ten(_Big_integer_flt& _Xval, const uint32_t _Power) noexcept {
    
    
    
    
    

    
    

    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]); 
}


[[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);
    }

    
    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;

    constexpr _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) {
#pragma warning(push)
#pragma warning(disable : 26454) 
            constexpr uint64_t _Extra_bits_mask = (1ULL << (_Total_number_of_bits - 1)) - 1;
#pragma warning(pop)
            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>;

    constexpr int32_t _Base_exponent = _Traits::_Mantissa_bits - 1;

    
    
    if (_Integer_bits_of_precision <= 64) {
        constexpr 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>;

    
    
    
    constexpr 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;

    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 _Whole_end = _Next;

    
    
    
    
    
    ptrdiff_t _Exponent_adjustment = _Whole_end - _Leading_zero_end;

    
    if (_Next != _Last && *_Next == '.') {
        ++_Next;
    }
    const char* const _Dot_end = _Next;

    

    
    
    if (_Exponent_adjustment == 0) {
        for (; _Next != _Last && *_Next == '0'; ++_Next) {
        }

        _Exponent_adjustment = _Dot_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;
        } 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;
    bool _Exp_abs_too_large    = false;
    ptrdiff_t _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 < 9223372036854775807i64 / 10 || (_Exponent == 9223372036854775807i64 / 10 && _Digit_value <= 9223372036854775807i64 % 10)) {
                _Exponent = _Exponent * 10 + _Digit_value;
            } else {
                _Exp_abs_too_large = true;
            }

            ++_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 (_Exp_abs_too_large) {
        if (_Exponent > 0) {
            _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
            return {_Next, errc::result_out_of_range};
        } else {
            _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
            return {_Next, errc::result_out_of_range};
        }
    }

    
    if (_Exponent > 0 && _Exponent_adjustment < 0) {
        if (_Is_hexadecimal) {
            const ptrdiff_t _Further_adjustment = (::std:: max)(-((_Exponent - 1) / 4 + 1), _Exponent_adjustment);
            _Exponent += _Further_adjustment * 4;
            _Exponent_adjustment -= _Further_adjustment;
        } else {
            const ptrdiff_t _Further_adjustment = (::std:: max)(-_Exponent, _Exponent_adjustment);
            _Exponent += _Further_adjustment;
            _Exponent_adjustment -= _Further_adjustment;
        }
    } else if (_Exponent < 0 && _Exponent_adjustment > 0) {
        if (_Is_hexadecimal) {
            const ptrdiff_t _Further_adjustment = (::std:: min)((-_Exponent - 1) / 4 + 1, _Exponent_adjustment);
            _Exponent += _Further_adjustment * 4;
            _Exponent_adjustment -= _Further_adjustment;
        } else {
            const ptrdiff_t _Further_adjustment = (::std:: min)(-_Exponent, _Exponent_adjustment);
            _Exponent += _Further_adjustment;
            _Exponent_adjustment -= _Further_adjustment;
        }
    }

    
    
    
    const int _Exponent_adjustment_multiplier{_Is_hexadecimal ? 4 : 1};

    
    
    if (_Exponent > _Maximum_temporary_decimal_exponent
        || _Exponent_adjustment > _Maximum_temporary_decimal_exponent / _Exponent_adjustment_multiplier) {
        _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
        return {_Next, errc::result_out_of_range}; 
    }

    if (_Exponent < _Minimum_temporary_decimal_exponent
        || _Exponent_adjustment < _Minimum_temporary_decimal_exponent / _Exponent_adjustment_multiplier) {
        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
        return {_Next, errc::result_out_of_range}; 
    }

    _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       = static_cast<int32_t>(_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);

    do { if (_Fmt == chars_format::general || _Fmt == chars_format::scientific || _Fmt == chars_format::fixed || _Fmt == chars_format::hex) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 1911, 0, "%s", "invalid format in from_chars()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid format in from_chars()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 1911, 0); } while (false); } ; } while (false);
#line 1912 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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";
        constexpr 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));
}

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_2<_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 {
        do { if (_Fmt == chars_format::general || _Fmt == chars_format::scientific || _Fmt == chars_format::fixed || _Fmt == chars_format::hex) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 2491, 0, "%s", "invalid format in to_chars()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"invalid format in to_chars()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv", 2491, 0); } while (false); } ; } while (false);
#line 2492 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2614 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"
#line 2615 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"
#line 2616 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\charconv"
#pragma external_header(pop)
#line 50 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\locale"





#pragma once




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 suppress this warning.")]] wbuffer_convert
    : public basic_streambuf<_Elem, _Traits> { 
private:
    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; 
                [[fallthrough]];

            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 (::std:: size(_Myback) <= _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{off_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{off_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 suppress this warning.")]] wstring_convert { 
private:
    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 508 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocbuf"
#line 509 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocbuf"
#pragma external_header(pop)
#line 12 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\locale"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

    messages_base() noexcept 
        : messages_base(0) {}
    explicit messages_base(size_t _Refs) noexcept : locale::facet(_Refs) {}
};

 template <class _Elem>
class messages : public messages_base { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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);
    }

     __declspec(dllimport) 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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 {}
};




template  locale::id messages<char>::id;
template  locale::id messages<wchar_t>::id;
#line 129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmes"




#line 134 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmes"
}


#pragma warning(pop)
#pragma pack(pop)
#line 140 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmes"
#line 141 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmes"
#pragma external_header(pop)
#line 13 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\locale"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) noexcept 
        : locale::facet(_Refs) {}
};

template <class _Elem>
class _Mpunct : public money_base { 
public:
    friend _Tidy_guard<_Mpunct>;

    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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

     __declspec(dllimport) static const bool intl; 
     __declspec(dllimport) 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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 { 
private:
    using _Mypunct0 = moneypunct<_Elem, false>;
    using _Mypunct1 = moneypunct<_Elem, true>;

public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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);
    }

     __declspec(dllimport) 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_v3(_Eb, &_Ep, &_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 { 
private:
    using _Mypunct0 = moneypunct<_Elem, false>;
    using _Mypunct1 = moneypunct<_Elem, true>;

public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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);
    }

     __declspec(dllimport) 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; 
                [[fallthrough]];

            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);
                [[fallthrough]];

            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;




template  const bool moneypunct<char, true>::intl;
template  const bool moneypunct<char, false>::intl;
template  locale::id moneypunct<char, true>::id;
template  locale::id moneypunct<char, false>::id;
template  locale::id money_get<char, istreambuf_iterator<char, char_traits<char>>>::id;
template  locale::id money_put<char, ostreambuf_iterator<char, char_traits<char>>>::id;

template  const bool moneypunct<wchar_t, true>::intl;
template  const bool moneypunct<wchar_t, false>::intl;
template  locale::id moneypunct<wchar_t, true>::id;
template  locale::id moneypunct<wchar_t, false>::id;
template  locale::id money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>::id;
template  locale::id money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>::id;
#line 898 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmon"











#line 910 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmon"





}



#pragma warning(pop)
#pragma pack(pop)
#line 922 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmon"
#line 923 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\xlocmon"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>, "Unsupported facet specialization; see N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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);
    }

     __declspec(dllimport) 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;




template  locale::id collate<char>::id;
template  locale::id collate<wchar_t>::id;
#line 133 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\locale"




#line 138 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this error.");

    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 241 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\locale"
#line 242 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\locale"
#pragma external_header(pop)
#line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"





#pragma once












#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"





#pragma once






#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\process.h"








#pragma once




#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_startup.h"








#pragma once


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















#pragma external_header(pop)
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_startup.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) 
#pragma external_header(pop)
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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;

__declspec(dllimport) int __cdecl _seh_filter_dll(
      unsigned long               _ExceptionNum,
      struct _EXCEPTION_POINTERS* _ExceptionPtr
    );

__declspec(dllimport) 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;

__declspec(dllimport) _crt_app_type __cdecl _query_app_type(void);

__declspec(dllimport) void __cdecl _set_app_type(
      _crt_app_type _Type
    );

typedef int (__cdecl *_UserMathErrorFunctionPointer)(struct _exception *);

__declspec(dllimport) void __cdecl __setusermatherr(
    _UserMathErrorFunctionPointer _UserMathErrorFunction
    );

int __cdecl _is_c_termination_complete(void);








__declspec(dllimport) errno_t __cdecl _configure_narrow_argv(
      _crt_argv_mode mode
    );

__declspec(dllimport) errno_t __cdecl _configure_wide_argv(
      _crt_argv_mode mode
    );



int __cdecl _initialize_narrow_environment(void);
int __cdecl _initialize_wide_environment(void);

__declspec(dllimport) char**    __cdecl _get_initial_narrow_environment(void);
__declspec(dllimport) 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);

__declspec(dllimport) char**    __cdecl __p__acmdln(void);
__declspec(dllimport) wchar_t** __cdecl __p__wcmdln(void);





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








typedef void (__cdecl* _PVFV)(void);
typedef int  (__cdecl* _PIFV)(void);
typedef void (__cdecl* _PVFI)(int);


    __declspec(dllimport) void __cdecl _initterm(
            _PVFV*  _First,
                                     _PVFV*  _Last
        );

    __declspec(dllimport) int  __cdecl _initterm_e(
               _PIFV*  _First,
                                     _PIFV*  _Last
        );
#line 127 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\corecrt_startup.h"










typedef struct _onexit_table_t
{
    _PVFV* _first;
    _PVFV* _last;
    _PVFV* _end;
} _onexit_table_t;

__declspec(dllimport) int __cdecl _initialize_onexit_table(
      _onexit_table_t* _Table
    );

__declspec(dllimport) int __cdecl _register_onexit_function(
      _onexit_table_t* _Table,
      _onexit_t        _Function
    );

__declspec(dllimport) int __cdecl _execute_onexit_table(
      _onexit_table_t* _Table
    );

__declspec(dllimport) int __cdecl _crt_atexit(
      _PVFV _Function
    );

__declspec(dllimport) 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.22621.0\\ucrt\\corecrt_startup.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 15 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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(dllimport) __declspec(noreturn) void __cdecl exit(  int _Code);
    __declspec(dllimport) __declspec(noreturn) void __cdecl _exit(  int _Code);
    __declspec(dllimport) __declspec(noreturn) void __cdecl _Exit(  int _Code);
    __declspec(dllimport) __declspec(noreturn) void __cdecl quick_exit(  int _Code);
    __declspec(dllimport) __declspec(noreturn) void __cdecl abort(void);

    __declspec(dllimport) int __cdecl system(  char const* _Command);

    __declspec(dllimport) void __cdecl _cexit(void);
    __declspec(dllimport) void __cdecl _c_exit(void);

    typedef void (__stdcall *_tls_callback_type)(void *, unsigned long, void *);
    __declspec(dllimport) void __cdecl _register_thread_local_exe_atexit_callback(  _tls_callback_type _Callback);

#line 57 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\process.h"



























typedef void     (__cdecl*   _beginthread_proc_type  )(void*);
typedef unsigned (__stdcall* _beginthreadex_proc_type)(void*);

__declspec(dllimport) uintptr_t __cdecl _beginthread(
          _beginthread_proc_type _StartAddress,
          unsigned               _StackSize,
      void*                  _ArgList
    );

__declspec(dllimport) void __cdecl _endthread(void);

 
__declspec(dllimport) uintptr_t __cdecl _beginthreadex(
       void*                    _Security,
           unsigned                 _StackSize,
           _beginthreadex_proc_type _StartAddress,
       void*                    _ArgList,
           unsigned                 _InitFlag,
      unsigned*                _ThrdAddr
    );

__declspec(dllimport) void __cdecl _endthreadex(
      unsigned _ReturnCode
    );





    __declspec(dllimport) int __cdecl _getpid(void);

    __declspec(dllimport) intptr_t __cdecl _cwait(
          int*     _TermStat,
               intptr_t _ProcHandle,
               int      _Action
        );

    __declspec(dllimport) intptr_t __cdecl _execl(
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _execle(
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _execlp(
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _execlpe(
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _execv(
          char const*        _FileName,
          char const* const* _Arguments
        );

    __declspec(dllimport) intptr_t __cdecl _execve(
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

    __declspec(dllimport) intptr_t __cdecl _execvp(
          char const*        _FileName,
          char const* const* _Arguments
        );

    __declspec(dllimport) intptr_t __cdecl _execvpe(
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

    __declspec(dllimport) intptr_t __cdecl _spawnl(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _spawnle(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _spawnlp(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _spawnlpe(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

    __declspec(dllimport) intptr_t __cdecl _spawnv(
            int                _Mode,
          char const*        _FileName,
          char const* const* _Arguments
        );

    __declspec(dllimport) intptr_t __cdecl _spawnve(
                int                _Mode,
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

    __declspec(dllimport) intptr_t __cdecl _spawnvp(
            int                _Mode,
          char const*        _FileName,
          char const* const* _Arguments
        );

    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) 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."))
    __declspec(dllimport) _GetDllProcAddrProcType __cdecl _getdllprocaddr(
                intptr_t _Handle,
          char*    _ProcedureName,
                intptr_t _Ordinal
        );

#line 233 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) 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."))
        __declspec(dllimport) int __cdecl getpid(void);

    #line 367 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\process.h"

#line 369 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\process.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#line 376 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\process.h"
#pragma external_header(pop)
#line 14 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stop_token"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stop_token"
#line 398 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stop_token"
#line 399 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\stop_token"
#pragma external_header(pop)
#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"

 class thread { 
public:
    class id;

    using native_handle_type = void*;

    thread() noexcept : _Thr{} {}

private:

    friend jthread;
#line 49 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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.get(); 
        ::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...>;
    }

#pragma warning(push) 
#pragma warning(disable : 5039) 
    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)>{});

        _Thr._Hnd =
            reinterpret_cast<void*>(:: _beginthreadex(nullptr, 0, _Invoker_proc, _Decay_copied.get(), 0, &_Thr._Id));

        if (_Thr._Hnd) { 
            (void) _Decay_copied.release();
        } else { 
            _Thr._Id = 0;
            _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
        }
    }
#pragma warning(pop)

public:
    template <class _Fn, class... _Args, enable_if_t<!is_same_v<_Remove_cvref_t<_Fn>, thread>, int> = 0>
    [[nodiscard("This temporary 'std::thread' is not joined or detached, " "so 'std::terminate' will be called at the end of the statement.")]] 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);
        }

        if (_Thrd_detach(_Thr) != _Thrd_success) {
            _Throw_Cpp_error(_INVALID_ARGUMENT);
        }

        _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();
    }

     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 189 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"
        for (;;) {
            const auto _Now = _Clock::now();
            if (_Abs_time <= _Now) {
                return;
            }

            _timespec64 _Tgt;
            (void) _To_timespec64_sys_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 = default; 

private:
    explicit id(_Thrd_id_t _Other_id) noexcept : _Id(_Other_id) {}

    _Thrd_id_t _Id = 0;

    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 224 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 thread::id{_Thr._Id};
}

 [[nodiscard]] inline thread::id this_thread::get_id() noexcept {
    return thread::id{_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 270 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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> {
    using _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 suppress this warning.")]] = thread::id;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[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("This temporary 'std::jthread' is implicitly joined at the end of the statement. " "If this is intentional, you can add '.join()' to suppress this warning. " "Otherwise, this 'std::jthread' should be stored in a variable.")]] 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 {
        if (this == ::std:: addressof(_Other)) {
            return *this;
        }

        _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 379 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"
}



#pragma warning(pop)
#pragma pack(pop)
#line 386 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"
#line 387 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\thread"
#pragma external_header(pop)
#line 20 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;

struct _Mtx_internal_imp_mirror {








    static constexpr size_t _Critical_section_size = 64;


#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
#line 48 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"

    static constexpr size_t _Critical_section_align = alignof(void*);

    int _Type;
    _Aligned_storage_t<_Critical_section_size, _Critical_section_align> _Cs_storage;
    long _Thread_id;
    int _Count;
};

static_assert(sizeof(_Mtx_internal_imp_mirror) == _Mtx_internal_imp_size, "inconsistent size for mutex");
static_assert(alignof(_Mtx_internal_imp_mirror) == _Mtx_internal_imp_alignment, "inconsistent alignment for mutex");

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() {
        if (_Mtx_lock(_Mymtx()) != _Thrd_success) {
            
            ::std:: _Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
        }

        if (!_Verify_ownership_levels()) {
            
            
            
            ::std:: _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
        }
    }

    [[nodiscard("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool try_lock() noexcept  {
        
        return _Mtx_trylock(_Mymtx()) == _Thrd_success;
    }

    void unlock() noexcept  {
        _Mtx_unlock(_Mymtx());
    }

    

protected:
    [[nodiscard("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool _Verify_ownership_levels() noexcept {
        if (_Mtx_storage_mirror._Count == 2147483647) {
            
            --_Mtx_storage_mirror._Count;
            return false;
        }

        return true;
    }

private:
    friend condition_variable;
    friend condition_variable_any;

    union {
        _Aligned_storage_t<_Mtx_internal_imp_size, _Mtx_internal_imp_alignment> _Mtx_storage;
        _Mtx_internal_imp_mirror _Mtx_storage_mirror;
    };

    _Mtx_t _Mymtx() noexcept { 
        return reinterpret_cast<_Mtx_t>(&_Mtx_storage);
    }
};

static_assert(sizeof(_Mutex_base) == _Mtx_internal_imp_size, "inconsistent size for mutex");
static_assert(alignof(_Mutex_base) == _Mtx_internal_imp_alignment, "inconsistent alignment for mutex");

 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() noexcept 
        : _Mutex_base(_Mtx_recursive) {}

    [[nodiscard("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool try_lock() noexcept {
        return _Mutex_base::try_lock() && _Verify_ownership_levels();
    }

    recursive_mutex(const recursive_mutex&)            = delete;
    recursive_mutex& operator=(const recursive_mutex&) = delete;
};

 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 = default;

    [[nodiscard("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] explicit unique_lock(_Mutex& _Mtx)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(false) { 
        _Pmtx->lock();
        _Owns = true;
    }

    [[nodiscard("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] unique_lock(_Mutex& _Mtx, adopt_lock_t) noexcept 
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(true) {} 

    unique_lock(_Mutex& _Mtx, defer_lock_t) noexcept
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(false) {} 

    [[nodiscard("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] unique_lock(_Mutex& _Mtx, try_to_lock_t)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Pmtx->try_lock()) {} 

    template <class _Rep, class _Period>
    [[nodiscard("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] 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("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] 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 197 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
    }

    [[nodiscard("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] unique_lock(unique_lock&& _Other) noexcept : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) {
        _Other._Pmtx = nullptr;
        _Other._Owns = false;
    }

    unique_lock& operator=(unique_lock&& _Other) noexcept  {
        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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool try_lock() {
        _Validate();
        _Owns = _Pmtx->try_lock();
        return _Owns;
    }

    template <class _Rep, class _Period>
    [[nodiscard("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] 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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
        _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 = nullptr;
    bool _Owns    = false;

    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 _Fn>
struct [[nodiscard]] _Unlock_call_guard {
    static_assert(
        is_trivially_copyable_v<_Fn>, "This scope guard is only used for trivially copyable function objects.");

    explicit _Unlock_call_guard(const _Fn& _Fx) noexcept : _Func(_Fx) {}

    ~_Unlock_call_guard() noexcept {
        if (_Valid) {
            _Func();
        }
    }

    _Unlock_call_guard(const _Unlock_call_guard&)            = delete;
    _Unlock_call_guard& operator=(const _Unlock_call_guard&) = delete;

    _Fn _Func;
    bool _Valid = true;
};

template <class _Lock>
struct [[nodiscard]] _Unlock_one_guard {
    explicit _Unlock_one_guard(_Lock& _Lk) noexcept : _Lk_ptr(::std:: addressof(_Lk)) {}

    ~_Unlock_one_guard() noexcept {
        if (_Lk_ptr) {
            _Lk_ptr->unlock();
        }
    }

    _Unlock_one_guard(const _Unlock_one_guard&)            = delete;
    _Unlock_one_guard& operator=(const _Unlock_one_guard&) = delete;

    _Lock* _Lk_ptr;
};

template <class... _LockN>
int _Try_lock_range(const int _First, const int _Last, _LockN&... _LkN) {
    using _Indices = index_sequence_for<_LockN...>;
    int _Next      = _First;

    auto _Unlocker = [_First, &_Next, &_LkN...]() noexcept { ::std:: _Unlock_locks(_First, _Next, _Indices{}, _LkN...); };
    _Unlock_call_guard<decltype(_Unlocker)> _Guard{_Unlocker};

    for (; _Next != _Last; ++_Next) {
        if (!::std:: _Try_lock_from_locks(_Next, _Indices{}, _LkN...)) { 
            return _Next;
        }
    }

    _Guard._Valid = false;
    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;
    }

    _Unlock_one_guard<_Lock0> _Guard{_Lk0};
    if (!_Lk1.try_lock()) {
        return 1;
    }

    _Guard._Lk_ptr = nullptr;
    return -1;
}

 template <class _Lock0, class _Lock1, class... _LockN>
[[nodiscard("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] 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; 

    {
        auto _Unlocker = [&_Backout_start, _Hard_lock, &_LkN...]() noexcept {
            ::std:: _Unlock_locks(_Backout_start, _Hard_lock + 1, _Indices{}, _LkN...);
        };
        _Unlock_call_guard<decltype(_Unlocker)> _Guard{_Unlocker};

        _Failed = ::std:: _Try_lock_range(0, _Hard_lock, _LkN...);
        if (_Failed == -1) {
            _Backout_start = 0; 
            _Failed        = ::std:: _Try_lock_range(_Hard_lock + 1, sizeof...(_LockN), _LkN...);
            if (_Failed == -1) { 
                _Guard._Valid = false;
                return -1;
            }
        }
        
    }

    ::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();
    {
        _Unlock_one_guard<_Lock0> _Guard{_Lk0};
        if (_Lk1.try_lock()) {
            _Guard._Lk_ptr = nullptr;
            return false;
        }
    }

    ::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("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] lock_guard { 
public:
    using mutex_type = _Mutex;

    explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { 
        _MyMutex.lock();
    }

    lock_guard(_Mutex& _Mtx, adopt_lock_t) noexcept 
        : _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("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] scoped_lock { 
public:
    explicit scoped_lock(_Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...) { 
        ::std:: lock(_Mtxes...);
    }

    explicit scoped_lock(adopt_lock_t, _Mutexes&... _Mtxes) noexcept 
        : _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("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " "a temporary to protect the rest of the current expression using the comma operator, you can cast " "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]] 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) noexcept 
        : _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() = default;
    explicit scoped_lock(adopt_lock_t) noexcept  {}

    scoped_lock(const scoped_lock&)            = delete;
    scoped_lock& operator=(const scoped_lock&) = delete;
};
#line 559 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"




#line 565 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"


#line 568 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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)) {
            __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)) {
        :: 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:
    condition_variable() noexcept  {
        _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) noexcept  { 
        
        _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;
        }

        
        
        _timespec64 _Tgt;
        const bool _Clamped     = _To_timespec64_sys_10_day_clamped(_Tgt, _Rel_time);
        const cv_status _Result = _Wait_until_sys_time(_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 697 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
        for (;;) {
            const auto _Now = _Clock::now();
            if (_Abs_time <= _Now) {
                return cv_status::timeout;
            }

            _timespec64 _Tgt;
            (void) _To_timespec64_sys_10_day_clamped(_Tgt, _Abs_time - _Now);
            const cv_status _Result = _Wait_until_sys_time(_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 719 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
        return _Wait_until1(_Lck, _Abs_time, _Pred);
    }

    

    void _Register(unique_lock<mutex>& _Lck, int* _Ready) noexcept { 
        _Cnd_register_at_thread_exit(_Mycnd(), _Lck.release()->_Mymtx(), _Ready);
    }

    void _Unregister(mutex& _Mtx) noexcept { 
        _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);
    }

    cv_status _Wait_until_sys_time(unique_lock<mutex>& _Lck, const _timespec64* _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);

        if (_Res == _Thrd_success) {
            return cv_status::no_timeout;
        } else {
            return cv_status::timeout;
        }
    }

    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;
            }

            _timespec64 _Tgt;
            const bool _Clamped = _To_timespec64_sys_10_day_clamped(_Tgt, _Abs_time - _Now);
            if (_Wait_until_sys_time(_Lck, &_Tgt) == cv_status::timeout && !_Clamped) {
                return _Pred();
            }
        }

        return true;
    }
};

struct _UInt_is_zero {
    const unsigned int& _UInt;

    [[nodiscard]] bool operator()() const noexcept {
        return _UInt == 0;
    }
};

 class timed_mutex { 
public:
    timed_mutex() = default;

    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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] 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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] 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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 830 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
        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;
    }

private:
    mutex _My_mutex;
    condition_variable _My_cond;
    unsigned int _My_locked = 0;
};

 class recursive_timed_mutex { 
public:
    recursive_timed_mutex() = default;

    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 {
                
                
                ::std:: _Throw_system_error(errc::resource_unavailable_try_again);
            }
        } else {
            while (_My_locked != 0) {
                _My_cond.wait(_Lock);
            }

            _My_locked = 1;
            _My_owner  = _Tid;
        }
    }

    [[nodiscard("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] 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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] 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("This function returns whether the operation succeeded in modifying object state. " "It is dangerous to ignore the return value.")]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 926 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
        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;
    }

private:
    mutex _My_mutex;
    condition_variable _My_cond;
    unsigned int _My_locked = 0;
    thread::id _My_owner;
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 959 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
#line 960 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\mutex"
#pragma external_header(pop)
#line 56 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {




#line 76 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"


#line 79 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"

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, class>
class vector;

 class format_error : public runtime_error {
    using runtime_error::runtime_error;
};

[[noreturn]] inline void _Throw_format_error(const char* const _Message) {
    throw format_error{_Message};
}

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, _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 _CharT>
struct _Decode_result {
    const _CharT* _Next_ptr;
    bool _Is_unicode_scalar_value; 
    
    
};


[[nodiscard]] constexpr _Decode_result<wchar_t> _Decode_utf(
    const wchar_t* _First, const wchar_t* _Last, char32_t& _Val) noexcept {
    ;
    _Val = static_cast<char32_t>(*_First);
    if (_Val < 0xD800) {
        return {_First + 1, true};
    } else if (_Val <= 0xDBFF) {
        
        if (_First + 1 == _Last) {
            _Val = 0xFFFD;
            return {_Last, false};
        }

        if (_First[1] < 0xDC00 || _First[1] > 0xDFFF) {
            
            _Val = 0xFFFD;
            return {_First + 1, false};
        }

        _Val = (_Val - 0xD800) << 10;
        _Val += _First[1] - 0xDC00;
        _Val += 0x10000;
        return {_First + 2, true};
    } else if (_Val <= 0xDFFF) {
        
        _Val = 0xFFFD;
        return {_First + 1, false};
    }

    return {_First + 1, true};
}

[[nodiscard]] constexpr _Decode_result<char> _Decode_utf(const char* _First, const char* _Last, char32_t& _Val) noexcept {
    ;
    
    
    
    
    
    
    _Val = static_cast<char32_t>(static_cast<unsigned char>(*_First));

    
    
    
    
    
    int _Num_bytes;
    if (_Val <= 0x7F) {
        return {_First + 1, true};
    } else if (_Val >= 0xC2 && _Val <= 0xDF) {
        _Num_bytes = 2;
    } else if (_Val >= 0xE0 && _Val <= 0xEF) {
        _Num_bytes = 3;
    } else if (_Val >= 0xF0 && _Val <= 0xF4) {
        _Num_bytes = 4;
    } else {
        
        _Val = 0xFFFD;
        return {_First + 1, false};
    }

    if (_First + 1 == _Last) {
        
        
        
        
        _Val = 0xFFFD;
        return {_Last, false};
    }

    switch (_Val) {
    case 0xE0:
        
        
        if (static_cast<unsigned char>(_First[1]) < 0xA0) {
            
            
            
            
            _Val = 0xFFFD;
            return {_First + 1, false};
        }
        break;
    case 0xED:
        if (static_cast<unsigned char>(_First[1]) > 0x9F) {
            _Val = 0xFFFD;
            return {_First + 1, false};
        }
        break;
    case 0xF0:
        if (static_cast<unsigned char>(_First[1]) < 0x90) {
            _Val = 0xFFFD;
            return {_First + 1, false};
        }
        break;
    case 0xF4:
        if (static_cast<unsigned char>(_First[1]) > 0x8F) {
            _Val = 0xFFFD;
            return {_First + 1, false};
        }
        break;
    }

    
    
    
    
    switch (_Num_bytes) {
    case 2:
        _Val &= 0b1'1111u;
        break;
    case 3:
        _Val &= 0b1111u;
        break;
    case 4:
        _Val &= 0b111u;
        break;
    }

    for (int _Idx = 1; _Idx < _Num_bytes; ++_Idx) {
        if (_First + _Idx >= _Last || static_cast<unsigned char>(_First[_Idx]) < 0x80
            || static_cast<unsigned char>(_First[_Idx]) > 0xBF) {
            
            _Val = 0xFFFD;
            return {_First + _Idx, false};
        }
        
        _Val = (_Val << 6) | (static_cast<unsigned char>(_First[_Idx]) & 0b11'1111u);
    }
    return {_First + _Num_bytes, true};
}

[[nodiscard]] constexpr _Decode_result<char32_t> _Decode_utf(
    const char32_t* _First, const char32_t* _Last, char32_t& _Val) noexcept {
    ;
    (void) _Last;
    _Val               = *_First;
    const bool _Is_usv = _Val < 0xD800 || (_Val > 0xDFFF && _Val <= 0x10FFFF);
    return {_First + 1, _Is_usv};
}

template <class _CharT>
class _Unicode_codepoint_iterator {
private:
    const _CharT* _First = nullptr;
    const _CharT* _Last  = nullptr;
    const _CharT* _Next  = nullptr;
    char32_t _Val        = 0;

public:
    using value_type      = char32_t;
    using difference_type = ptrdiff_t;

    constexpr _Unicode_codepoint_iterator(const _CharT* _First_val, const _CharT* _Last_val) noexcept
        : _First(_First_val), _Last(_Last_val) {
        _Next = _Decode_utf(_First, _Last, _Val)._Next_ptr;
    }

    constexpr _Unicode_codepoint_iterator() = default;

    constexpr _Unicode_codepoint_iterator& operator++() noexcept {
        _First = _Next;
        if (_First != _Last) {
            _Next = _Decode_utf(_First, _Last, _Val)._Next_ptr;
        }

        return *this;
    }
    constexpr _Unicode_codepoint_iterator operator++(int) noexcept {
        auto _Old = *this;
        ++*this;
        return _Old;
    }

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

    [[nodiscard]] constexpr const _CharT* _Position() const noexcept {
        return _First;
    }

    [[nodiscard]] constexpr bool operator==(default_sentinel_t) const noexcept {
        return _First == _Last;
    }
    [[nodiscard]] constexpr bool operator==(const _Unicode_codepoint_iterator& _Other) const noexcept {
        ;
        return _First == _Other._First && _Last == _Other._Last;
    }
};












class _GB11_LeftHand_regex {
private:
    enum _State_t : bool { _Start, _ExtPic };

    _State_t _State = _Start;

public:
    [[nodiscard]] constexpr bool operator==(const _GB11_LeftHand_regex&) const noexcept = default;

    [[nodiscard]] constexpr bool _Match(
        const _Grapheme_Break_property_values _Left_gbp, _Extended_Pictographic_property_values _Left_ExtPic) noexcept {
        switch (_State) {
        case _Start:
            if (_Left_ExtPic == _Extended_Pictographic_property_values::_Extended_Pictographic_value) {
                _State = _ExtPic;
            }
            return false;
        case _ExtPic:
            if (_Left_gbp == _Grapheme_Break_property_values::_ZWJ_value) {
                _State = _Start;
                return true;
            } else if (_Left_gbp != _Grapheme_Break_property_values::_Extend_value) {
                _State = _Start;
                return false;
            }
            return false;
        default:
            ;
            return false;
        }
    }
};

template <class _CharT>
class _Grapheme_break_property_iterator {
private:
    using _Wrapped_iter_type = _Unicode_codepoint_iterator<_CharT>;

    _Wrapped_iter_type _WrappedIter;
    _GB11_LeftHand_regex _GB11_rx;

public:
    [[nodiscard]] constexpr bool operator==(default_sentinel_t) const noexcept {
        return _WrappedIter == default_sentinel;
    }

    [[nodiscard]] constexpr bool operator==(const _Grapheme_break_property_iterator&) const noexcept = default;

    using difference_type = ptrdiff_t;
    using value_type      = iter_value_t<_Wrapped_iter_type>;

    constexpr _Grapheme_break_property_iterator(const _CharT* _First, const _CharT* _Last)
        : _WrappedIter(_First, _Last) {}

    constexpr _Grapheme_break_property_iterator() = default;

    constexpr _Grapheme_break_property_iterator& operator++() noexcept {
        auto _Left_gbp     = _Grapheme_Break_property_data._Get_property_for_codepoint(*_WrappedIter);
        auto _Left_ExtPic  = _Extended_Pictographic_property_data._Get_property_for_codepoint(*_WrappedIter);
        auto _Right_gbp    = _Grapheme_Break_property_values::_No_value;
        auto _Right_ExtPic = _Extended_Pictographic_property_values::_No_value;
        size_t _Num_RIs    = 0;
        for (;; _Left_gbp = _Right_gbp, _Left_ExtPic = _Right_ExtPic) {
            ++_WrappedIter;
            if (_WrappedIter == default_sentinel) {
                return *this; 
            }
            _Right_gbp    = _Grapheme_Break_property_data._Get_property_for_codepoint(*_WrappedIter);
            _Right_ExtPic = _Extended_Pictographic_property_data._Get_property_for_codepoint(*_WrappedIter);
            
            
            const bool _GB11_Match = _GB11_rx._Match(_Left_gbp, _Left_ExtPic);
            
            if (_Left_gbp == _Grapheme_Break_property_values::_Regional_Indicator_value) {
                ++_Num_RIs;
            } else {
                _Num_RIs = 0;
            }

            if (_Left_gbp == _Grapheme_Break_property_values::_CR_value
                && _Right_gbp == _Grapheme_Break_property_values::_LF_value) {
                continue; 
            }

            if (_Left_gbp == _Grapheme_Break_property_values::_Control_value
                || _Left_gbp == _Grapheme_Break_property_values::_CR_value
                || _Left_gbp == _Grapheme_Break_property_values::_LF_value) {
                return *this; 
            }

            if (_Right_gbp == _Grapheme_Break_property_values::_Control_value
                || _Right_gbp == _Grapheme_Break_property_values::_CR_value
                || _Right_gbp == _Grapheme_Break_property_values::_LF_value) {
                return *this; 
            }

            if (_Left_gbp == _Grapheme_Break_property_values::_L_value
                && (_Right_gbp == _Grapheme_Break_property_values::_L_value
                    || _Right_gbp == _Grapheme_Break_property_values::_V_value
                    || _Right_gbp == _Grapheme_Break_property_values::_LV_value
                    || _Right_gbp == _Grapheme_Break_property_values::_LVT_value)) {
                continue; 
            }

            if ((_Left_gbp == _Grapheme_Break_property_values::_LV_value
                    || _Left_gbp == _Grapheme_Break_property_values::_V_value)
                && (_Right_gbp == _Grapheme_Break_property_values::_V_value
                    || _Right_gbp == _Grapheme_Break_property_values::_T_value)) {
                continue; 
            }

            if ((_Left_gbp == _Grapheme_Break_property_values::_LVT_value
                    || _Left_gbp == _Grapheme_Break_property_values::_T_value)
                && _Right_gbp == _Grapheme_Break_property_values::_T_value) {
                continue; 
            }

            if (_Right_gbp == _Grapheme_Break_property_values::_Extend_value
                || _Right_gbp == _Grapheme_Break_property_values::_ZWJ_value) {
                continue; 
            }

            if (_Right_gbp == _Grapheme_Break_property_values::_SpacingMark_value) {
                continue; 
            }

            if (_Left_gbp == _Grapheme_Break_property_values::_Prepend_value) {
                continue; 
            }

            if (_GB11_Match && _Right_ExtPic == _Extended_Pictographic_property_values::_Extended_Pictographic_value) {
                continue; 
            }

            if (_Left_gbp == _Grapheme_Break_property_values::_Regional_Indicator_value
                && _Right_gbp == _Grapheme_Break_property_values::_Regional_Indicator_value && _Num_RIs % 2 != 0) {
                continue; 
                          
            }
            return *this;
        }
    }
    constexpr _Grapheme_break_property_iterator operator++(int) noexcept {
        auto _Old = *this;
        ++*this;
        return _Old;
    }

    [[nodiscard]] constexpr const _CharT* _Position() const noexcept {
        return _WrappedIter._Position();
    }

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

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 _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 _Ty, class _Context, class _Formatter = typename _Context::template formatter_type<remove_const_t<_Ty>>>
concept _Formattable_with = semiregular<_Formatter>
                         && requires(_Formatter& __f, const _Formatter& __cf, _Ty&& __t, _Context __fc,
                             basic_format_parse_context<typename _Context::char_type> __pc) {
                                { __f.parse(__pc) } -> same_as<typename decltype(__pc)::iterator>;
                                { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
                            };

template <class _Ty, class _CharT>
inline constexpr bool _Is_basic_string_like_for = false;

template <class _CharT, class _Traits, class _Alloc>
inline constexpr bool _Is_basic_string_like_for<basic_string<_CharT, _Traits, _Alloc>, _CharT> = true;

template <class _CharT, class _Traits>
inline constexpr bool _Is_basic_string_like_for<basic_string_view<_CharT, _Traits>, _CharT> = true;

template <class _Context>
struct _Format_arg_traits {
    using _Char_type = typename _Context::char_type;

    
    
    template <_Formattable_with<_Context> _Ty>
    static auto _Type_eraser();

    template <class _Ty>
    using _Storage_type = decltype(_Type_eraser<remove_reference_t<_Ty>>());

    template <class _Ty>
    static constexpr size_t _Storage_size = sizeof(_Storage_type<_Ty>);
};

 template <class _Context>
class basic_format_args;


template <class _CharT>
struct _Format_handler;


 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 _Td = remove_const_t<_Ty>;
                  
                  using _Tq = conditional_t<_Formattable_with<const _Ty, _Context>, const _Ty, _Ty>;
                  typename _Context::template formatter_type<_Td> _Formatter;
                  _Parse_ctx.advance_to(_Formatter.parse(_Parse_ctx));
                  _Format_ctx.advance_to(
                      _Formatter.format(*const_cast<_Tq*>(static_cast<const _Td*>(_Ptr)), _Format_ctx));
              }) {
            
            using _Tq = conditional_t<_Formattable_with<const _Ty, _Context>, const _Ty, _Ty>;
            static_assert(_Formattable_with<_Tq, _Context>);
        }

        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 operator bool() const noexcept {
        return _Active_state != _Basic_format_arg_type::_None;
    }

    
    
    template <_Formattable_with<_Context> _Ty>
    static basic_format_arg _Make_from(_Ty& _Val) noexcept {
        using _Erased_type = typename _Format_arg_traits<_Context>::template _Storage_type<_Ty>;

        if constexpr (is_same_v<_Erased_type, basic_string_view<_CharType>>) {
            return basic_format_arg(_Erased_type{_Val.data(), _Val.size()});
        } else
#line 743 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
        {
            return basic_format_arg(static_cast<_Erased_type>(_Val));
        }
    }

    template <class _Visitor>
    decltype(auto) _Visit(_Visitor&& _Vis) {
        switch (_Active_state) {
        case _Basic_format_arg_type::_None:
            return ::std:: forward<_Visitor>(_Vis)(_No_state);
        case _Basic_format_arg_type::_Int_type:
            return ::std:: forward<_Visitor>(_Vis)(_Int_state);
        case _Basic_format_arg_type::_UInt_type:
            return ::std:: forward<_Visitor>(_Vis)(_UInt_state);
        case _Basic_format_arg_type::_Long_long_type:
            return ::std:: forward<_Visitor>(_Vis)(_Long_long_state);
        case _Basic_format_arg_type::_ULong_long_type:
            return ::std:: forward<_Visitor>(_Vis)(_ULong_long_state);
        case _Basic_format_arg_type::_Bool_type:
            return ::std:: forward<_Visitor>(_Vis)(_Bool_state);
        case _Basic_format_arg_type::_Char_type:
            return ::std:: forward<_Visitor>(_Vis)(_Char_state);
        case _Basic_format_arg_type::_Float_type:
            return ::std:: forward<_Visitor>(_Vis)(_Float_state);
        case _Basic_format_arg_type::_Double_type:
            return ::std:: forward<_Visitor>(_Vis)(_Double_state);
        case _Basic_format_arg_type::_Long_double_type:
            return ::std:: forward<_Visitor>(_Vis)(_Long_double_state);
        case _Basic_format_arg_type::_Pointer_type:
            return ::std:: forward<_Visitor>(_Vis)(_Pointer_state);
        case _Basic_format_arg_type::_CString_type:
            return ::std:: forward<_Visitor>(_Vis)(_CString_state);
        case _Basic_format_arg_type::_String_type:
            return ::std:: forward<_Visitor>(_Vis)(_String_state);
        case _Basic_format_arg_type::_Custom_type:
            return ::std:: forward<_Visitor>(_Vis)(_Custom_state);
        default:
            do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 780, 0, "%s", "basic_format_arg is in impossible state")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"basic_format_arg is in impossible state\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 780, 0); } while (false); } ; } while (false);
            int _Dummy{};
            return ::std:: forward<_Visitor>(_Vis)(_Dummy);
        }
    }

private:
    friend basic_format_args<_Context>;
    friend _Format_handler<_CharType>;
    friend _Format_arg_traits<_Context>;

    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) {}

    _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 _Context>
template <_Formattable_with<_Context> _Ty>
auto _Format_arg_traits<_Context>::_Type_eraser() {
    using _Td = remove_const_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 if constexpr (is_same_v<_Td, float>) {
        return float{};
    } else if constexpr (is_same_v<_Td, double>) {
        return double{};
    } else if constexpr (is_same_v<_Td, long double>) {
        return static_cast<long double>(42);
    } else if constexpr (_Is_basic_string_like_for<_Td, _Char_type>) {
        return basic_string_view<_Char_type>{};
    } else if constexpr (_Is_any_of_v<decay_t<_Td>, _Char_type*, const _Char_type*>) {
        return static_cast<const _Char_type*>(nullptr);
    } else if constexpr (is_void_v<remove_pointer_t<_Td>> || is_same_v<_Td, nullptr_t>) {
        return static_cast<const void*>(nullptr);
    } else {
        int _Dummy{};
        return typename basic_format_arg<_Context>::handle{_Dummy};
    }
}

 template <class _Visitor, class _Context>
decltype(auto) visit_format_arg(_Visitor&& _Vis, basic_format_arg<_Context> _Arg) {
    return _Arg._Visit(::std:: forward<_Visitor>(_Vis));
}


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 (65001) {
    
    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 979 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
}

inline constexpr char32_t _Width_estimate_intervals[] = { 
    0x1100u, 0x1160u, 0x2329u, 0x232Bu, 0x2E80u, 0x303Fu, 0x3040u, 0xA4D0u, 0xAC00u, 0xD7A4u, 0xF900u, 0xFB00u, 0xFE10u,
    0xFE1Au, 0xFE30u, 0xFE70u, 0xFF00u, 0xFF61u, 0xFFE0u, 0xFFE7u, 0x1F300u, 0x1F650u, 0x1F900u, 0x1FA00u, 0x20000u,
    0x2FFFEu, 0x30000u, 0x3FFFEu};

[[nodiscard]] constexpr int _Unicode_width_estimate(const char32_t _Ch) noexcept {
    
    int _Result = 1;
    for (const auto& _Bound : _Width_estimate_intervals) {
        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{65001};



#line 1034 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
        char32_t _Ch;
        const auto [_Next, _Is_usv] = _Decode_utf(_First, _Last, _Ch);
        ;
        return _Is_usv ? static_cast<int>(_Next - _First) : -1;
    }

public:
    [[nodiscard]] constexpr const char* _Find_encoded(const char* _First, const char* const _Last, const char _Val) const {
        
        
        if constexpr (_Statically_Utf8) {
            return ::std:: _Find_unchecked(_First, _Last, _Val);
        } else {
            if (this->_Cvt._Mbcurmax == 1 || this->_Cvt._Mbcurmax == 4) {
                
                return ::std:: _Find_unchecked(_First, _Last, _Val);
            }

            while (_First != _Last && *_First != _Val) {
                const int _Units = this->_Double_byte_encoding_code_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 _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);
            }
        }
    }































#line 1131 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
};

template <bool _Statically_Utf8>
class _Fmt_codec<wchar_t, _Statically_Utf8> {
public:
    [[nodiscard]] constexpr const wchar_t* _Find_encoded(
        const wchar_t* const _First, const wchar_t* const _Last, const wchar_t _Val) const {
        return ::std:: _Find_unchecked(_First, _Last, _Val);
    }

    [[nodiscard]] constexpr int _Units_in_next_character(
        const wchar_t* _First, const wchar_t* const _Last) const noexcept {
        char32_t _Ch;
        const auto [_Next, _Is_usv] = _Decode_utf(_First, _Last, _Ch);
        ;
        return _Is_usv ? static_cast<int>(_Next - _First) : -1;
    }






#line 1155 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
};

template <class _CharT>
[[nodiscard]] constexpr _Fmt_codec<_CharT> _Get_fmt_codec() {
    return {};
}

template <class _CharT>
    requires (is_same_v<_CharT, char> && !_Is_execution_charset_self_synchronizing())
[[nodiscard]] const _Fmt_codec<_CharT>& _Get_fmt_codec() {
    using _CodecType = _Fmt_codec<_CharT>;

    static once_flag _Flag;
    alignas(_CodecType) static unsigned char _Storage[sizeof(_CodecType)];

    ::std:: call_once(_Flag, [] { ::std:: construct_at(reinterpret_cast<_CodecType*>(&_Storage)); });

    return *::std:: launder(reinterpret_cast<const _CodecType*>(&_Storage));
}

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 = _Get_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{};
        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 auto& _Codec = _Get_fmt_codec<_CharT>();

    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;
}

template <class _Ty>
inline constexpr bool _Is_signed_or_unsigned_large_integer_t =
    _Is_any_of_v<remove_cv_t<_Ty>, int, unsigned int, long, unsigned long, long long, unsigned long long>;



class _Width_checker {
public:
    template <class _Ty>
    [[nodiscard]] constexpr unsigned long long operator()(const _Ty _Value) const {
        if constexpr (_Is_signed_or_unsigned_large_integer_t<_Ty>) {
            if constexpr (is_signed_v<_Ty>) {
                if (_Value < 0) {
                    _Throw_format_error("Negative width.");
                }
            }
            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_signed_or_unsigned_large_integer_t<_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,


#line 1790 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
        };
        auto _Cat = _Presentation_type_category::_Default;
        switch (_Narrow_type) {
        case '\0':
            break;




#line 1800 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
        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


#line 1853 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
            ) {
                if constexpr (is_same_v<_CharT, char>) {
                    _Throw_format_error("Invalid presentation type for char");
                } else {
                    _Throw_format_error("Invalid presentation type for 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


#line 1894 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
            ) {
                _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);
    }
};

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... _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];

#pragma warning(push)
#pragma warning(disable : 6386) 
    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) {
            
            _Index_array[_Arg_index + 1] = _Format_arg_index{_Store_index + sizeof(_Ty)};
        }
    }
#pragma warning(pop)

    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;
        }


        
        if constexpr (is_same_v<_Erased_type, basic_string_view<_CharType>>) {
            _Store_impl<_Erased_type>(_Arg_index, _Arg_type, _Erased_type{_Val.data(), _Val.size()});
        } else
#line 2018 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
        {
            _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:
            do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 2059, 0, "%s", "Invalid basic_format_arg type")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid basic_format_arg type\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 2059, 0); } while (false); } ; } while (false);
            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 _CharType = typename _Context::char_type;
        size_t _Result  = 0;

        for (size_t _Idx = 0; _Idx < _Num_args; ++_Idx) {
            const auto _Packed_index = _Index_array[_Idx];
            const auto _Arg_type     = _Packed_index._Type();
            if (_Arg_type == _Basic_format_arg_type::_String_type) {
                const auto _Arg_storage =
                    reinterpret_cast<const unsigned char*>(_Index_array + _Num_args) + _Packed_index._Index;
                const auto _View = _Get_value_from_memory<basic_string_view<_CharType>>(_Arg_storage);
                _Result += _View.size();
            } else if (_Arg_type == _Basic_format_arg_type::_CString_type) {
                _Result += 32; 
            } else {
                _Result += 8; 
            }
        }
        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 ::std:: bit_cast<_Ty>(_Temp);
    }

    size_t _Num_args                      = 0;
    const _Format_arg_index* _Index_array = nullptr;
};

template <class _Context, class... _Args>
basic_format_args(_Format_arg_store<_Context, _Args...>) -> basic_format_args<_Context>;






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_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, class _OutputIt>
[[nodiscard]] _OutputIt _Widen_and_copy(const char* _First, const char* const _Last, _OutputIt _Out) {
    for (; _First != _Last; ++_First, (void) ++_Out) {
        *_Out = static_cast<_CharT>(*_First);
    }

    return _Out;
}

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];
    char* _End = _Buffer;

    if constexpr (is_floating_point_v<_Arithmetic>) {
        if ((::std:: isnan)(_Value)) {
            if ((::std:: signbit)(_Value)) {
                *_End++ = '-';
            }

            :: memcpy(_End, "nan", 3);
            _End += 3;
        }
    }

    if (_End == _Buffer) {
        const to_chars_result _Result = ::std:: to_chars(_Buffer, ::std:: end(_Buffer), _Value);
        ;
        _End = _Result.ptr;
    }

    return _Widen_and_copy<_CharT>(_Buffer, _End, ::std:: move(_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 _Widen_and_copy<_CharT>(_Buffer, _End, ::std:: move(_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:
            do { if (false) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 2535, 0, "%s", "Invalid alignment")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Invalid alignment\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 2535, 0); } while (false); } ; } while (false);
            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) noexcept {
    for (; _First != _Last; ++_First) {
        if (*_First >= 'a' && *_First <= 'z') {
            *_First -= 'a' - 'A';
        }
    }
}

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   = _Widen_and_copy<_CharT>(_First, _Last - _Grouped, ::std:: move(_Out));
    _First = _Last - _Grouped;

    for (; _Separators > 0; --_Separators) {
        if (_Repeats > 0) {
            --_Repeats;
        } else {
            --_Group_it;
        }

        *_Out++ = _Separator;
        _Out    = _Widen_and_copy<_CharT>(_First, _First + *_Group_it, ::std:: move(_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);





#line 2678 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"

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);

#pragma warning(push)
#pragma warning(disable : 4296) 
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)) {
            if constexpr (is_same_v<_CharT, char>) {
                _Throw_format_error("integral cannot be stored in char");
            } else {
                _Throw_format_error("integral cannot be stored in wchar_t");
            }
        }
        _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;

    switch (_Specs._Type) {
    case 'B':
    case 'b':
        _Base = 2;
        break;
    case 'X':
    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 (_Specs._Type == 'X') {
        _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) {
        _Out = _Write_sign(::std:: move(_Out), _Specs._Sgn, _Value < _Integral{0});
        _Out = _Widen_and_copy<_CharT>(_Prefix.data(), _Prefix.data() + _Prefix.size(), ::std:: move(_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 _Widen_and_copy<_CharT>(_Buffer_start, _End, ::std:: move(_Out));
    };

    if (_Write_leading_zeroes) {
        return _Writer(::std:: move(_Out));
    }

    return _Write_aligned(::std:: move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
}
#pragma warning(pop)

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'


#line 2845 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
    ) {
        return _Write_integral(::std:: move(_Out), _Value, _Specs, _Locale);
    }

    ;





#line 2856 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"

    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  = 'e';
    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;
        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;
        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;
    }

    const auto _Is_negative = (::std:: signbit)(_Value);

    if ((::std:: isnan)(_Value)) {
        _Result.ptr = _Buffer;
        if (_Is_negative) {
            ++_Result.ptr; 
        }

        :: memcpy(_Result.ptr, "nan", 3);
        _Result.ptr += 3;
    } else {
        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);

    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 -= 'a' - 'A';
    }

    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 && (_Specs._Type == 'g' || _Specs._Type == 'G')) {
                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 = _Widen_and_copy<_CharT>(_Buffer_start, _Exponent_start, ::std:: move(_Out));
        if (_Specs._Alt && _Append_decimal) {
            *_Out++ = '.';
        }

        for (; _Zeroes_to_append > 0; --_Zeroes_to_append) {
            *_Out++ = '0';
        }

        return _Widen_and_copy<_CharT>(_Exponent_start, _Result.ptr, ::std:: move(_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 = 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>
class _Measure_string_prefix_iterator_utf {
private:
    _Grapheme_break_property_iterator<_CharT> _WrappedIter;

public:
    [[nodiscard]] constexpr bool operator==(const _Measure_string_prefix_iterator_utf&) const noexcept = default;

    [[nodiscard]] constexpr bool operator==(default_sentinel_t) const noexcept {
        return _WrappedIter == default_sentinel;
    }

    using difference_type = ptrdiff_t;
    using value_type      = int;

    constexpr _Measure_string_prefix_iterator_utf(const _CharT* _First, const _CharT* _Last)
        : _WrappedIter(_First, _Last) {}

    constexpr _Measure_string_prefix_iterator_utf() = default;

    [[nodiscard]] constexpr value_type operator*() const {
        return _Unicode_width_estimate(*_WrappedIter);
    }

    constexpr _Measure_string_prefix_iterator_utf& operator++() noexcept {
        ++_WrappedIter;
        return *this;
    }

    constexpr _Measure_string_prefix_iterator_utf operator++(int) noexcept {
        auto _Old = *this;
        ++*this;
        return _Old;
    }

    [[nodiscard]] constexpr const _CharT* _Position() const {
        return _WrappedIter._Position();
    }
};

class _Measure_string_prefix_iterator_legacy {
private:
    _Fmt_codec<char> _Codec = _Get_fmt_codec<char>();
    const char* _First      = nullptr;
    const char* _Last       = nullptr;
    int _Units              = 0;

    void _Update_units() {
        if (_First < _Last) {
            _Units = _Codec._Units_in_next_character(_First, _Last);
        } else {
            _Units = -1;
        }
    }

public:
    [[nodiscard]] bool operator==(default_sentinel_t) const noexcept {
        return _First == _Last;
    }
    [[nodiscard]] bool operator==(const _Measure_string_prefix_iterator_legacy& _Rhs) const noexcept {
        return _First == _Rhs._First && _Last == _Rhs._Last;
    }

    using difference_type = ptrdiff_t;
    using value_type      = int;

    _Measure_string_prefix_iterator_legacy(const char* _First_val, const char* _Last_val)
        : _First(_First_val), _Last(_Last_val) {
        _Update_units();
    }

    _Measure_string_prefix_iterator_legacy() = default;

    _Measure_string_prefix_iterator_legacy& operator++() noexcept {
        _First += _Units;
        _Update_units();
        return *this;
    }
    _Measure_string_prefix_iterator_legacy operator++(int) noexcept {
        auto _Old = *this;
        ++*this;
        return _Old;
    }
    [[nodiscard]] value_type operator*() const noexcept {
        return _Units;
    }

    [[nodiscard]] const char* _Position() const noexcept {
        return _First;
    }
};

template <class _CharT>
using _Measure_string_prefix_iterator =
    conditional_t<is_same_v<_CharT, char> && !_Is_execution_charset_self_synchronizing(),
        _Measure_string_prefix_iterator_legacy, _Measure_string_prefix_iterator_utf<_CharT>>;

template <class _CharT>
[[nodiscard]] const _CharT* _Measure_string_prefix(const basic_string_view<_CharT> _Value, int& _Width) {
    
    
    const int _Max_width = _Width;
    const auto _First    = _Value.data();
    const auto _Last     = _First + _Value.size();
    _Measure_string_prefix_iterator<_CharT> _Pfx_iter(_First, _Last);
    int _Estimated_width = 0; 

    constexpr auto _Max_int = (numeric_limits<int>::max)();

    while (_Pfx_iter != default_sentinel) {
        if (_Estimated_width == _Max_width && _Max_width >= 0) {
            
            break;
        }

        const int _Character_width = *_Pfx_iter;

        if (_Max_int - _Character_width < _Estimated_width) { 
            
            if (_Max_width < 0) { 
                _Width = _Max_int;
                return _Last;
            }
            break;
        }

        _Estimated_width += _Character_width;
        if (_Estimated_width > _Max_width && _Max_width >= 0) {
            
            _Estimated_width -= _Character_width;
            break;
        }
        ++_Pfx_iter;
    }

    _Width = _Estimated_width;
    return _Pfx_iter._Position();
}





















































































































#line 3378 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"

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) {
    ;
    ;
    ;
    ;





#line 3392 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"

    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 { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 3439, 0, "%s", "The custom handler should be structurally unreachable for _Arg_formatter")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"The custom handler should be structurally unreachable for _Arg_formatter\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format", 3439, 0); } 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>::_Make_from(_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<_CharT[_Nx], _CharT> : _Formatter_base<_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 {
public:
    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});
        }
    }

    [[nodiscard]] constexpr basic_string_view<_CharT> get() const noexcept {
        return _Str;
    }

private:
    basic_string_view<_CharT> _Str;
};

 template <class... _Args>
using format_string = basic_format_string<char, type_identity_t<_Args>...>;

 template <class... _Args>
using wformat_string = 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) {
    static_assert((_Formattable_with<remove_cvref_t<_Args>, _Context> && ...),
        "Cannot format an argument. To make type T formattable, provide a formatter<T> specialization. "
        "See N4950 [format.arg.store]/2 and [formatter.requirements].");
    return _Format_arg_store<_Context, _Args...>{_Vals...};
}

 template <class... _Args>
[[nodiscard]] auto make_wformat_args(_Args&&... _Vals) {
    static_assert((_Formattable_with<remove_cvref_t<_Args>, wformat_context> && ...),
        "Cannot format an argument. To make type T formattable, provide a formatter<T> specialization. "
        "See N4950 [format.arg.store]/2 and [formatter.requirements].");
    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) {
    
    using _Dependent_char = decltype((void) _Out, char{});
    if constexpr (is_same_v<_OutputIt, _Fmt_it>) {
        _Format_handler<_Dependent_char> _Handler(_Out, _Fmt, _Args);
        _Parse_format_string(_Fmt, _Handler);
        return _Out;
    } else {
        _Fmt_iterator_buffer<_OutputIt, char> _Buf(::std:: move(_Out));
        _Format_handler<_Dependent_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) {
    
    using _Dependent_char = decltype((void) _Out, wchar_t{});
    if constexpr (is_same_v<_OutputIt, _Fmt_wit>) {
        _Format_handler<_Dependent_char> _Handler(_Out, _Fmt, _Args);
        _Parse_format_string(_Fmt, _Handler);
        return _Out;
    } else {
        _Fmt_iterator_buffer<_OutputIt, wchar_t> _Buf(::std:: move(_Out));
        _Format_handler<_Dependent_char> _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) {
    
    using _Dependent_char = decltype((void) _Out, char{});
    if constexpr (is_same_v<_OutputIt, _Fmt_it>) {
        _Format_handler<_Dependent_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<_Dependent_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) {
    
    using _Dependent_char = decltype((void) _Out, wchar_t{});
    if constexpr (is_same_v<_OutputIt, _Fmt_wit>) {
        _Format_handler<_Dependent_char> _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<_Dependent_char> _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 format_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Fmt.get(), ::std:: make_format_args(_Args...));
}

 template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Fmt.get(), ::std:: make_wformat_args(_Args...));
}

 template <output_iterator<const char&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Loc, _Fmt.get(), ::std:: make_format_args(_Args...));
}

 template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Loc, _Fmt.get(), ::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 format_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Fmt.get(), ::std:: make_format_args(_Args...));
}

 template <class... _Types>
[[nodiscard]] wstring format(const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Fmt.get(), ::std:: make_wformat_args(_Args...));
}

 template <class... _Types>
[[nodiscard]] string format(const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Loc, _Fmt.get(), ::std:: make_format_args(_Args...));
}

 template <class... _Types>
[[nodiscard]] wstring format(const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Loc, _Fmt.get(), ::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 format_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.get(), ::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 wformat_string<_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.get(), ::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 format_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.get(), ::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 wformat_string<_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.get(), ::std:: make_wformat_args(_Args...));
    return {.out = _Buf._Out(), .size = _Buf._Count()};
}

 template <class... _Types>
[[nodiscard]] size_t formatted_size(const format_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<char> _Buf;
    ::std:: vformat_to(_Fmt_it{_Buf}, _Fmt.get(), ::std:: make_format_args(_Args...));
    return _Buf._Count();
}

 template <class... _Types>
[[nodiscard]] size_t formatted_size(const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<wchar_t> _Buf;
    ::std:: vformat_to(_Fmt_wit{_Buf}, _Fmt.get(), ::std:: make_wformat_args(_Args...));
    return _Buf._Count();
}

 template <class... _Types>
[[nodiscard]] size_t formatted_size(const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<char> _Buf;
    ::std:: vformat_to(_Fmt_it{_Buf}, _Loc, _Fmt.get(), ::std:: make_format_args(_Args...));
    return _Buf._Count();
}

 template <class... _Types>
[[nodiscard]] size_t formatted_size(const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<wchar_t> _Buf;
    ::std:: vformat_to(_Fmt_wit{_Buf}, _Loc, _Fmt.get(), ::std:: make_wformat_args(_Args...));
    return _Buf._Count();
}
















































#line 3939 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"




}



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

#line 3951 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#line 3952 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#line 3953 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\format"
#pragma external_header(pop)
#line 38 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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) {}

    template <class _Elem2, class _Traits>
    friend basic_ostream<_Elem2, _Traits>& operator<<(basic_ostream<_Elem2, _Traits>& _Ostr, const _Fillobj& _Manip) {
        
        static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for setfill");

        _Ostr.fill(_Manip._Fill);
        return _Ostr;
    }

    _Elem _Fill; 
};

 template <class _Elem>
[[nodiscard]] _Fillobj<_Elem> setfill(_Elem _Ch) {
    return _Fillobj<_Elem>(_Ch);
}

template <class _Money>
struct _Monobj { 
    _Monobj(_Money& _Val_arg, bool _Intl_arg) : _Val(_Val_arg), _Intl(_Intl_arg) {}

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, const _Monobj& _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 _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Monobj& _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;
    }

    _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 _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 _Ptr>
struct _Timeobj { 
    _Timeobj(_Ptr _Tptr_arg, const _Elem* _Fmt_arg) : _Tptr(_Tptr_arg), _Fmtfirst(_Fmt_arg) {
        for (_Fmtlast = _Fmtfirst; *_Fmtlast != 0; ++_Fmtlast) { 
        }
    }

    template <class _Elem2, class _Traits>
    friend basic_istream<_Elem2, _Traits>& operator>>(basic_istream<_Elem2, _Traits>& _Istr, const _Timeobj& _Manip) {
        
        static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for get_time");

        using _Myis   = basic_istream<_Elem, _Traits>;
        using _Iter   = istreambuf_iterator<_Elem, _Traits>;
        using _Mytget = time_get<_Elem, _Iter>;

        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 _Elem2, class _Traits>
    friend basic_ostream<_Elem2, _Traits>& operator<<(basic_ostream<_Elem2, _Traits>& _Ostr, const _Timeobj& _Manip) {
        
        static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for put_time");

        using _Myos   = basic_ostream<_Elem, _Traits>;
        using _Iter   = ostreambuf_iterator<_Elem, _Traits>;
        using _Mytput = time_put<_Elem, _Iter>;

        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;
    }

    _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>
[[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 _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;

    template <class _OsTraits, class _QuTraits = _Traits>
    friend basic_ostream<_Elem, _OsTraits>& operator<<(
        basic_ostream<_Elem, _OsTraits>& _Ostr, const _Quote_out& _Manip) {
        
        static_assert(
            is_void_v<_QuTraits> || is_same_v<_QuTraits, _OsTraits>, "quoted() traits must match basic_ostream traits");

        using _Myos = basic_ostream<_Elem, _OsTraits>;

        const _Elem* const _Last = _Manip._Ptr + _Manip._Size;

        _Sizet _Size = _Manip._Size + 2; 
        for (const _Elem* _Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr) {
            if (_OsTraits::eq(*_Ptr, _Manip._Delim) || _OsTraits::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 (_OsTraits::eq_int_type(_OsTraits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                        _State |= ios_base::badbit; 
                        break;
                    }
                }
            }

            if (_State == ios_base::goodbit
                && _OsTraits::eq_int_type(_OsTraits::eof(),
                    _Ostr.rdbuf()->sputc(_Manip._Delim))) { 
                _State |= ios_base::badbit;
            }

            for (const _Elem* _Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr) { 
                if ((_OsTraits::eq(*_Ptr, _Manip._Delim) || _OsTraits::eq(*_Ptr, _Manip._Escape))
                    && _State == ios_base::goodbit
                    && _OsTraits::eq_int_type(_OsTraits::eof(),
                        _Ostr.rdbuf()->sputc(_Manip._Escape))) { 
                    _State |= ios_base::badbit; 
                    break;
                }

                if (_State == ios_base::goodbit
                    && _OsTraits::eq_int_type(_OsTraits::eof(),
                        _Ostr.rdbuf()->sputc(*_Ptr))) { 
                    _State |= ios_base::badbit; 
                    break;
                }
            }

            if (_State == ios_base::goodbit
                && _OsTraits::eq_int_type(_OsTraits::eof(),
                    _Ostr.rdbuf()->sputc(_Manip._Delim))) { 
                _State |= ios_base::badbit;
            }

            if (_State == ios_base::goodbit) {
                for (; 0 < _Pad; --_Pad) { 
                    if (_OsTraits::eq_int_type(_OsTraits::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;
    }

    const _Elem* _Ptr; 
    _Sizet _Size; 
    _Elem _Delim; 
    _Elem _Escape; 

    _Quote_out& operator=(const _Quote_out&) = delete;
};

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) {}

    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Quote_in& _Manip) {
        
        using _Out_type = _Quote_out<_Elem, _Traits, typename _Mystr::size_type>;

        return _Ostr << _Out_type{_Manip._Str.c_str(), _Manip._Str.size(), _Manip._Delim, _Manip._Escape};
    }

    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, const _Quote_in& _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;
    }

    _Mystr& _Str; 
    _Elem _Delim; 
    _Elem _Escape; 
};

 template <class _Elem>
[[nodiscard]] _Quote_out<_Elem, void, size_t> quoted(
    const _Elem* _Ptr, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
    const size_t _Size = char_traits<_Elem>::length(_Ptr);
    return {_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('\\')) {
    return {_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('\\')) {
    return {_Str.data(), _Str.size(), _Delim, _Escape};
}
#line 366 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {_Str, _Delim, _Escape};
}

template <class _Arg>
struct _Smanip { 
    _Smanip(void(__cdecl* _Left)(ios_base&, _Arg), _Arg _Val) : _Pfun(_Left), _Manarg(_Val) {}

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, const _Smanip& _Manip) {
        
        (*_Manip._Pfun)(_Istr, _Manip._Manarg);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Smanip& _Manip) {
        
        (*_Manip._Pfun)(_Ostr, _Manip._Manarg);
        return _Ostr;
    }

    void(__cdecl* _Pfun)(ios_base&, _Arg); 
    _Arg _Manarg; 
};

 extern "C++" [[nodiscard]]  _Smanip<ios_base::fmtflags> __cdecl resetiosflags(ios_base::fmtflags);
 extern "C++" [[nodiscard]]  _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags);
 extern "C++" [[nodiscard]]  _Smanip<int> __cdecl setbase(int);
 extern "C++" [[nodiscard]]  _Smanip<streamsize> __cdecl setprecision(streamsize);
 extern "C++" [[nodiscard]]  _Smanip<streamsize> __cdecl setw(streamsize);
}


#pragma warning(pop)
#pragma pack(pop)
#line 406 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iomanip"
#line 407 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\iomanip"
#pragma external_header(pop)
#line 39 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#line 40 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#line 41 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

[[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;
}

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;
}
#line 83 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"


namespace chrono {
    










    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 339 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
            return *this;
        }
        constexpr year& operator-=(const years& _Years) noexcept {



            _Year -= static_cast<short>(_Years.count());
#line 347 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _To, class _From>
    inline constexpr bool
        _Duration_underflows_with = !treat_as_floating_point_v<typename _From::rep>
                                 && _From::period::den / _Gcd(_From::period::den, _To::period::den)
                                        > 9223372036854775807i64 / (_To::period::num / _Gcd(_From::period::num, _To::period::num));

    template <class _To, class _From>
    [[nodiscard]] constexpr _To _Duration_cast_underflow_to_zero(const _From& _Dur) {
        if constexpr (_Duration_underflows_with<_To, _From>) {
            return _To{};
        } else {
            return ::std::chrono:: duration_cast<_To>(_Dur);
        }
    }

    template <class _To, class _From>
    [[nodiscard]] constexpr common_type_t<_To, _From> _Remove_duration_part(const _From& _Val) {
        if constexpr (_Duration_underflows_with<_To, _From>) {
            return _Val;
        } else {
            const auto _Dp = ::std::chrono:: duration_cast<_To>(_Val);
            return _Val - _Dp;
        }
    }

     template <class _Duration>
    class hh_mm_ss {
    public:
        static_assert(_Is_duration_v<_Duration>,
            "N4950 [time.hms.overview]/2 mandates Duration to be a specialization of chrono::duration.");

        static constexpr unsigned int fractional_width = [] {
            
            
            
            auto _Den = _Duration::period::den;
            do { if (_Duration::period::num > 0 && _Den > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono", 1585, 0, "%s", "Numerator and denominator can't be less than 1.")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Numerator and denominator can't be less than 1.\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono", 1585, 0); } while (false); } ; } while (false);
            unsigned int _Power_of_2_in_den = 0u;
            unsigned int _Power_of_5_in_den = 0u;
            for (; _Den % 2 == 0; _Den /= 2, ++_Power_of_2_in_den) {
            }
            for (; _Den % 5 == 0; _Den /= 5, ++_Power_of_5_in_den) {
            }

            if (_Den != 1) {
                return 6u;
            }
            const auto _Result = (::std:: max)(_Power_of_2_in_den, _Power_of_5_in_den);
            return _Result > 18u ? 6u : _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{_Duration_cast_underflow_to_zero<::std::chrono:: hours>(::std::chrono:: abs(_Dur))},
              _Mins{_Duration_cast_underflow_to_zero<::std::chrono:: minutes>(
                  _Remove_duration_part<::std::chrono:: hours>(::std::chrono:: abs(_Dur)))},
              _Secs{_Duration_cast_underflow_to_zero<::std::chrono:: seconds>(
                  _Remove_duration_part<::std::chrono:: minutes>(_Remove_duration_part<::std::chrono:: hours>(::std::chrono:: abs(_Dur))))} {
            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>(_Remove_duration_part<::std::chrono:: seconds>(::std::chrono:: abs(_Dur)));
            }
        }

        [[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 1712 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
    };

    template <class _Duration>
    [[noreturn]] void _Throw_nonexistent_local_time(const local_time<_Duration>& _Tp, const local_info& _Info) {
        throw (nonexistent_local_time{_Tp, _Info});
    }

     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 1735 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
    };

    template <class _Duration>
    [[noreturn]] void _Throw_ambiguous_local_time(const local_time<_Duration>& _Tp, const local_info& _Info) {
        throw (ambiguous_local_time{_Tp, _Info});
    }

    

     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(), __std_tzdb_sys_info_type::_Full);
        }

        template <class _Duration>
        [[nodiscard]] local_info get_info(const local_time<_Duration>& _Local) const {
            return _Get_local_info(_Local, __std_tzdb_sys_info_type::_Full);
        }

        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_local_info(_Local, __std_tzdb_sys_info_type::_Offset_and_range);
            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.time_since_epoch(), __std_tzdb_sys_info_type::_Offset_only);
            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, __std_tzdb_sys_info_type _Type) const {
            using _Internal_duration = duration<__std_tzdb_epoch_milli, milli>;
            const auto _Internal_dur = ::std::chrono:: duration_cast<_Internal_duration>(_Dur);

            
            
            
            const string _Tz_arg = _Name + static_cast<char>(_Type);

            const auto _Tz_len = _Name.length();

            const unique_ptr<__std_tzdb_sys_info, _Tzdb_deleter<__std_tzdb_sys_info>> _Info{
                __std_tzdb_get_sys_info(_Tz_arg.c_str(), _Tz_len, _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 ? _Info->_Abbrev : ""};
        }

        template <class _Duration>
        [[nodiscard]] local_info _Get_local_info(
            const local_time<_Duration>& _Local, __std_tzdb_sys_info_type _Type) const {
            local_info _Info{};
            const auto _Time_since_ep = _Local.time_since_epoch();
            _Info.first               = _Get_info(_Time_since_ep, _Type);

            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}).time_since_epoch(), _Type);

                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}).time_since_epoch(), _Type);

                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;
        }

        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 1922 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2013 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2046 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
                _Zones.reserve(_Tzdb.zones.size());
                for (const auto& _Tz : _Tzdb.zones) {
                    _Zones.emplace_back(_Tz.name());
                }

                vector<time_zone_link> _Links;
                _Links.reserve(_Tzdb.links.size());
                for (const auto& _Link : _Tzdb.links) {
                    _Links.emplace_back(_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 2337 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 2370 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>,
            "N4950 [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 2651 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
        }
    };
} 

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 2782 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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{2018}, chrono::June, 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 2836 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
    };
} 
#line 2839 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>,
                "N4950 [time.clock.cast.sys]/2: Mandates: SourceClock::to_sys(t) "
                "returns a sys_time<Duration2> for some type Duration2");
            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>,
                "N4950 [time.clock.cast.sys]/5: Mandates: DestClock::from_sys(t) "
                "returns a time_point<DestClock, Duration2> for some type Duration2");
            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>,
                "N4950 [time.clock.cast.utc]/2: Mandates: SourceClock::to_utc(t) "
                "returns a utc_time<Duration2> for some type Duration2");
            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>,
                "N4950 [time.clock.cast.utc]/5: Mandates: DestClock::from_utc(t) "
                "returns a time_point<DestClock, Duration2> for some type Duration2");
            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 (N4950 [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 (N4950 [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) {
                        const _SubsecondType _Sub{*_Subsecond};

                        if constexpr (!treat_as_floating_point_v<typename _DurationType::rep>) {
                            using _CastedType = duration<int64_t, typename _DurationType::period>;
                            if (::std::chrono:: duration_cast<_CastedType>(_Sub) != _Sub) {
                                return false;
                            }
                        }

                        _Result += ::std::chrono:: duration_cast<_DurationType>(_Sub);
                    }

                    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 _Leap_second_rep : unsigned int {
            _None, 
            _All, 
            _File_time 
        };

        template <class _DurationType>
        [[nodiscard]] bool _Make_time_point(_DurationType& _Dur, _Leap_second_rep _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 _Leap_second_rep _Original_leap{_Leap};
            if (_Leap == _Leap_second_rep::_File_time) {
                _Leap =
                    _Dur < file_clock::_Cutoff.time_since_epoch() ? _Leap_second_rep::_None : _Leap_second_rep::_All;
            }

            if (_Second > (_Leap == _Leap_second_rep::_All ? 60 : 59)) {
                return false;
            }

            
            
            
            
            

            if (_Leap == _Leap_second_rep::_All) {
                if constexpr (!_Can_represent<_DurationType, seconds>()) {
                    
                    return false;
                } else {
                    
                    
                    const auto& _Tzdb{::std::chrono:: get_tzdb()};

                    const bool _Possible_insertion{_Second == 60};
                    const sys_seconds _Target_sys_time{
                        ::std::chrono:: floor<seconds>(_Dur) - (_Possible_insertion ? seconds{1} : seconds{0})};
                    const auto& _Ls_vector{_Tzdb.leap_seconds};
                    const auto _It{::std:: upper_bound(_Ls_vector.begin(), _Ls_vector.end(), _Target_sys_time)};
                    const bool _Match_leap{_It != _Ls_vector.end() && *_It == _Target_sys_time + seconds{1}};

                    if (_Match_leap) {
                        if (!_It->_Positive()) { 
                            if (_Second >= 59) {
                                return false;
                            }
                        }
                    } else { 
                        if (_Possible_insertion) {
                            return false;
                        }
                    }

                    const auto _Offset = _It == _Ls_vector.begin() ? seconds{0} : _Prev_iter(_It)->_Elapsed();
                    _Dur += ::std::chrono:: duration_cast<_DurationType>(_Offset);

                    if (_Original_leap == _Leap_second_rep::_File_time) {
                        _Dur -= ::std::chrono:: duration_cast<_DurationType>(
                            filesystem::_File_time_clock::_Skipped_filetime_leap_seconds);
                    }
                }
            }

            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' && (_State & ~ios_base::eofbit) == ios_base::goodbit) {
                if (_First == _Last) {
                    _State |= ios_base::failbit | ios_base::eofbit;
                    break;
                } else 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[_Max_int_dig];
            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::eofbit) == 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::_Leap_second_rep::_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::_Leap_second_rep::_None)) {
            _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::_Leap_second_rep::_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::_Leap_second_rep::_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::_Leap_second_rep::_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::_Leap_second_rep::_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;

        friend basic_istream<_CharT, _Traits>& operator>>(
            basic_istream<_CharT, _Traits>& _Is, _Time_parse_iomanip_c_str&& _Tpi) {
            from_stream(_Is, _Tpi._Fmt, _Tpi._Tp, _Tpi._Abbrev, _Tpi._Offset); 
            return _Is;
        }

        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;

        friend basic_istream<_CharT, _Traits>& operator>>(
            basic_istream<_CharT, _Traits>& _Is, _Time_parse_iomanip&& _Tpi) {
            from_stream(_Is, _Tpi._Fmt.c_str(), _Tpi._Tp, _Tpi._Abbrev, _Tpi._Offset); 
            return _Is;
        }

        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 _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{'\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 _CharT, class _Traits>
        friend basic_ostream<_CharT, _Traits>& operator<<(
            basic_ostream<_CharT, _Traits>& _Os, const _Local_time_format_t& _Val) {
            
            
            return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T %Z}", L"{:L%F %T %Z}")), _Val);
        }
    };

     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) {
        _Write_seconds(_Os, hh_mm_ss{_Val});
    }

    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>) {
            return _Fill_tm(hh_mm_ss{_Val});
        } 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, 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>
    [[nodiscard]] 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;
    }

    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 N4950 [time.format]/1.");
#line 5299 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
                    }
                }
            } else {
                if (_Specs._Precision != -1) {
                    throw format_error("Precision specification invalid for non-chrono::duration type, " "see N4950 [time.format]/1.");
#line 5305 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;




            constexpr auto _Get_table_entry_type = &_Table_entry::_Type;
#line 5359 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"

            if (auto _It = ::std::ranges:: find(_Table, _Type, _Get_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' || _Type == 'x' || _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' || _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);


                    if constexpr (is_same_v<_CharT, char>) {
                        if (_Specs._Localized) {
                            wostringstream _Wstream;
                            _Wstream.imbue(_FormatCtx.locale());

                            wchar_t _Fmt_str[4];
                            _Chrono_spec<wchar_t> _Wspec{._Modifier = _Spec._Modifier, ._Type = _Spec._Type};
                            _Wstream << ::std:: put_time<wchar_t>(&_Time, _Fmt_string(_Wspec, _Fmt_str));

                            _Stream << _Convert_wide_to_narrow<char_traits<char>>(
                                __std_code_page::_Utf8, _Wstream.view(), allocator<char>{});

                            continue;
                        }
                    }
#line 5461 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"

                    _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.");
                    }

                    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(_Duration_cast_underflow_to_zero<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 'H':
                
                _Os << ::std:: format((_Choose_literal<_CharT>("{:02}", L"{:02}")), _Time.tm_hour);
                return true;
            case 'T':
                
                _Os << ::std:: format((_Choose_literal<_CharT>("{:02}:{:02}:", L"{:02}:{:02}:")), _Time.tm_hour, _Time.tm_min);
                [[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>
                          || _Is_specialization_v<_Ty, hh_mm_ss>) {
                return;
            }

            const auto _Validate = [&] {
                constexpr bool _Is_ymd =
                    _Is_any_of_v<_Ty, year_month_day, year_month_day_last, year_month_weekday, year_month_weekday_last>;

                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 5753 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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.");
            }
        }

        _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 5992 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"

inline namespace literals {
    inline namespace chrono_literals {
         [[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 6004 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"

}


#pragma warning(pop)
#pragma pack(pop)
#line 6011 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#line 6012 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\chrono"
#pragma external_header(pop)
#line 60 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
#line 61 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"




class QEvent;
class QTimerEvent;
class QChildEvent;
struct QMetaObject;
class QVariant;
class QObjectPrivate;
class QObject;
class QThread;
class QWidget;
class QAccessibleWidget;

class QRegExp;
#line 78 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

class QRegularExpression;
#line 81 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"


#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"



struct QDynamicMetaObjectData;

typedef QList<QObject*> QObjectList;

__declspec(dllimport) void qt_qFindChildren_helper(const QObject *parent, const QString &name,
                                           const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options);
__declspec(dllimport) void qt_qFindChildren_helper(const QObject *parent, const QRegExp &re,
                                           const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options);
__declspec(dllimport) void qt_qFindChildren_helper(const QObject *parent, const QRegularExpression &re,
                                           const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options);
__declspec(dllimport) QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo, Qt::FindChildOptions options);

class __declspec(dllimport) QObjectData {
    QObjectData(const QObjectData &) = delete; QObjectData &operator=(const QObjectData &) = delete;
public:
    QObjectData() = default;
    virtual ~QObjectData() = 0;
    QObject *q_ptr;
    QObject *parent;
    QObjectList children;

    uint isWidget : 1;
    uint blockSig : 1;
    uint wasDeleted : 1;
    uint isDeletingChildren : 1;
    uint sendChildEvents : 1;
    uint receiveChildEvents : 1;
    uint isWindow : 1; 
    uint deleteLaterCalled : 1;
    uint unused : 24;
    int postedEvents;
    QDynamicMetaObjectData *metaObject;
    QMetaObject *dynamicMetaObject() const;


    enum { CheckForParentChildLoopsWarnDepth = 4096 };
#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
};


class __declspec(dllimport) QObject
{
    public: __pragma(warning(push))  static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); virtual int qt_metacall(QMetaObject::Call, int, void **); static inline QString tr(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } __declspec(deprecated) static inline QString trUtf8(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } private:   static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); __pragma(warning(pop)) struct QPrivateSignal {}; 

    
    inline QObjectPrivate* d_func() { __pragma(warning(push))  return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr)); __pragma(warning(pop)) } inline const QObjectPrivate* d_func() const { __pragma(warning(push))  return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr)); __pragma(warning(pop)) } friend class QObjectPrivate;

public:
     explicit QObject(QObject *parent=nullptr);
    virtual ~QObject();

    virtual bool event(QEvent *event);
    virtual bool eventFilter(QObject *watched, QEvent *event);








#line 149 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

    QString objectName() const;
    void setObjectName(const QString &name);

    inline bool isWidgetType() const { return d_ptr->isWidget; }
    inline bool isWindowType() const { return d_ptr->isWindow; }

    inline bool signalsBlocked() const noexcept { return d_ptr->blockSig; }
    bool blockSignals(bool b) noexcept;

    QThread *thread() const;
    void moveToThread(QThread *thread);

    int startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer);

    __forceinline
    int startTimer(std::chrono::milliseconds time, Qt::TimerType timerType = Qt::CoarseTimer)
    {
        return startTimer(int(time.count()), timerType);
    }
#line 170 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
    void killTimer(int id);

    template<typename T>
    inline T findChild(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
    {
        typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType;
        return static_cast<T>(qt_qFindChild_helper(this, aName, ObjType::staticMetaObject, options));
    }

    template<typename T>
    inline QList<T> findChildren(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
    {
        typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType;
        QList<T> list;
        qt_qFindChildren_helper(this, aName, ObjType::staticMetaObject,
                                reinterpret_cast<QList<void *> *>(&list), options);
        return list;
    }













#line 202 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
#line 203 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"


    template<typename T>
    inline QList<T> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
    {
        typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType;
        QList<T> list;
        qt_qFindChildren_helper(this, re, ObjType::staticMetaObject,
                                reinterpret_cast<QList<void *> *>(&list), options);
        return list;
    }
#line 215 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

    inline const QObjectList &children() const { return d_ptr->children; }

    void setParent(QObject *parent);
    void installEventFilter(QObject *filterObj);
    void removeEventFilter(QObject *obj);

    static QMetaObject::Connection connect(const QObject *sender, const char *signal,
                        const QObject *receiver, const char *member, Qt::ConnectionType = Qt::AutoConnection);

    static QMetaObject::Connection connect(const QObject *sender, const QMetaMethod &signal,
                        const QObject *receiver, const QMetaMethod &method,
                        Qt::ConnectionType type = Qt::AutoConnection);

    inline QMetaObject::Connection connect(const QObject *sender, const char *signal,
                        const char *member, Qt::ConnectionType type = Qt::AutoConnection) const;









    
    template <typename Func1, typename Func2>
    static inline QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
                                     const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot,
                                     Qt::ConnectionType type = Qt::AutoConnection)
    {
        typedef QtPrivate::FunctionPointer<Func1> SignalType;
        typedef QtPrivate::FunctionPointer<Func2> SlotType;

        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal");
#line 251 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        
        static_assert(bool(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount)), "The slot requires more arguments than the signal provides.");
#line 255 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
        static_assert(bool((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value)), "Signal and slot arguments are not compatible.");
#line 257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
        static_assert(bool((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value)), "Return type of the slot is not compatible with the return type of the signal.");
#line 259 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        const int *types = nullptr;
        if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
            types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();

        return connectImpl(sender, reinterpret_cast<void **>(&signal),
                           receiver, reinterpret_cast<void **>(&slot),
                           new QtPrivate::QSlotObject<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
                                           typename SignalType::ReturnType>(slot),
                            type, types, &SignalType::Object::staticMetaObject);
    }

    
    template <typename Func1, typename Func2>
    static inline typename std::enable_if<int(QtPrivate::FunctionPointer<Func2>::ArgumentCount) >= 0, QMetaObject::Connection>::type
            connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot)
    {
        return connect(sender, signal, sender, slot, Qt::DirectConnection);
    }

    
    template <typename Func1, typename Func2>
    static inline typename std::enable_if<int(QtPrivate::FunctionPointer<Func2>::ArgumentCount) >= 0 &&
                                          !QtPrivate::FunctionPointer<Func2>::IsPointerToMemberFunction, QMetaObject::Connection>::type
            connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, const QObject *context, Func2 slot,
                    Qt::ConnectionType type = Qt::AutoConnection)
    {
        typedef QtPrivate::FunctionPointer<Func1> SignalType;
        typedef QtPrivate::FunctionPointer<Func2> SlotType;

        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal");
#line 291 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        
        static_assert(bool(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount)), "The slot requires more arguments than the signal provides.");
#line 295 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
        static_assert(bool((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value)), "Signal and slot arguments are not compatible.");
#line 297 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
        static_assert(bool((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value)), "Return type of the slot is not compatible with the return type of the signal.");
#line 299 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        const int *types = nullptr;
        if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
            types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();

        return connectImpl(sender, reinterpret_cast<void **>(&signal), context, nullptr,
                           new QtPrivate::QStaticSlotObject<Func2,
                                                 typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
                                                 typename SignalType::ReturnType>(slot),
                           type, types, &SignalType::Object::staticMetaObject);
    }

    
    template <typename Func1, typename Func2>
    static inline typename std::enable_if<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::type
            connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot)
    {
        return connect(sender, signal, sender, std::move(slot), Qt::DirectConnection);
    }

    
    template <typename Func1, typename Func2>
    static inline typename std::enable_if<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::type
            connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, const QObject *context, Func2 slot,
                    Qt::ConnectionType type = Qt::AutoConnection)
    {
        typedef QtPrivate::FunctionPointer<Func1> SignalType;
        const int FunctorArgumentCount = QtPrivate::ComputeFunctorArgumentCount<Func2 , typename SignalType::Arguments>::Value;

        static_assert(bool((FunctorArgumentCount >= 0)), "Signal and slot arguments are not compatible.");
#line 330 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
        const int SlotArgumentCount = (FunctorArgumentCount >= 0) ? FunctorArgumentCount : 0;
        typedef typename QtPrivate::FunctorReturnType<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value>::Value SlotReturnType;

        static_assert(bool((QtPrivate::AreArgumentsCompatible<SlotReturnType, typename SignalType::ReturnType>::value)), "Return type of the slot is not compatible with the return type of the signal.");
#line 335 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal");
#line 338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        const int *types = nullptr;
        if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
            types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();

        return connectImpl(sender, reinterpret_cast<void **>(&signal), context, nullptr,
                           new QtPrivate::QFunctorSlotObject<Func2, SlotArgumentCount,
                                typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value,
                                typename SignalType::ReturnType>(std::move(slot)),
                           type, types, &SignalType::Object::staticMetaObject);
    }
#line 350 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

    static bool disconnect(const QObject *sender, const char *signal,
                           const QObject *receiver, const char *member);
    static bool disconnect(const QObject *sender, const QMetaMethod &signal,
                           const QObject *receiver, const QMetaMethod &member);
    inline bool disconnect(const char *signal = nullptr,
                           const QObject *receiver = nullptr, const char *member = nullptr) const
        { return disconnect(this, signal, receiver, member); }
    inline bool disconnect(const QObject *receiver, const char *member = nullptr) const
        { return disconnect(this, nullptr, receiver, member); }
    static bool disconnect(const QMetaObject::Connection &);





    template <typename Func1, typename Func2>
    static inline bool disconnect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
                                  const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot)
    {
        typedef QtPrivate::FunctionPointer<Func1> SignalType;
        typedef QtPrivate::FunctionPointer<Func2> SlotType;

        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal");
#line 375 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        
        static_assert(bool((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value)), "Signal and slot arguments are not compatible.");
#line 379 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

        return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, reinterpret_cast<void **>(&slot),
                              &SignalType::Object::staticMetaObject);
    }
    template <typename Func1>
    static inline bool disconnect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
                                  const QObject *receiver, void **zero)
    {
        
        
        
        ((!zero) ? static_cast<void>(0) : qt_assert("!zero", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h", 390));
        typedef QtPrivate::FunctionPointer<Func1> SignalType;
        return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, zero,
                              &SignalType::Object::staticMetaObject);
    }
#line 396 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"



    void dumpObjectTree(); 
    void dumpObjectInfo(); 
#line 402 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
    void dumpObjectTree() const;
    void dumpObjectInfo() const;


    bool setProperty(const char *name, const QVariant &value);
    QVariant property(const char *name) const;
    QList<QByteArray> dynamicPropertyNames() const;
#line 410 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"










public :
    void destroyed(QObject * = nullptr);
    void objectNameChanged(const QString &objectName, QPrivateSignal);

public:
    inline QObject *parent() const { return d_ptr->parent; }

    inline bool inherits(const char *classname) const
        { return const_cast<QObject *>(this)->qt_metacast(classname) != nullptr; }

public :
    void deleteLater();

protected:
    QObject *sender() const;
    int senderSignalIndex() const;
    int receivers(const char* signal) const;
    bool isSignalConnected(const QMetaMethod &signal) const;

    virtual void timerEvent(QTimerEvent *event);
    virtual void childEvent(QChildEvent *event);
    virtual void customEvent(QEvent *event);

    virtual void connectNotify(const QMetaMethod &signal);
    virtual void disconnectNotify(const QMetaMethod &signal);

protected:
    QObject(QObjectPrivate &dd, QObject *parent = nullptr);

protected:
    QScopedPointer<QObjectData> d_ptr;

    static const QMetaObject staticQtMetaObject;
    friend inline const QMetaObject *qt_getQtMetaObject() noexcept;

    friend struct QMetaObject;
    friend struct QMetaObjectPrivate;
    friend class QMetaCallEvent;
    friend class QApplication;
    friend class QApplicationPrivate;
    friend class QCoreApplication;
    friend class QCoreApplicationPrivate;
    friend class QWidget;
    friend class QAccessibleWidget;
    friend class QThreadData;

private:
    QObject(const QObject &) = delete; QObject &operator=(const QObject &) = delete;
    

private:
    static QMetaObject::Connection connectImpl(const QObject *sender, void **signal,
                                               const QObject *receiver, void **slotPtr,
                                               QtPrivate::QSlotObjectBase *slot, Qt::ConnectionType type,
                                               const int *types, const QMetaObject *senderMetaObject);

    static bool disconnectImpl(const QObject *sender, void **signal, const QObject *receiver, void **slot,
                               const QMetaObject *senderMetaObject);

};

inline QMetaObject::Connection QObject::connect(const QObject *asender, const char *asignal,
                                            const char *amember, Qt::ConnectionType atype) const
{ return connect(asender, asignal, this, amember, atype); }

inline const QMetaObject *qt_getQtMetaObject() noexcept
{ return &QObject::staticQtMetaObject; }





























#line 517 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

template <class T>
inline T qobject_cast(QObject *object)
{
    typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType;
    static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<ObjType>::Value), "qobject_cast requires the type to have a Q_OBJECT macro");
#line 524 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
    return static_cast<T>(ObjType::staticMetaObject.cast(object));
}

template <class T>
inline T qobject_cast(const QObject *object)
{
    typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType;
    static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<ObjType>::Value), "qobject_cast requires the type to have a Q_OBJECT macro");
#line 533 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
    return static_cast<T>(ObjType::staticMetaObject.cast(object));
}


template <class T> inline const char * qobject_interface_iid()
{ return nullptr; }




#line 544 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"







#line 552 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"


__declspec(dllimport) QDebug operator<<(QDebug, const QObject *);
#line 556 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

class QSignalBlocker
{
public:
    inline explicit QSignalBlocker(QObject *o) noexcept;
    inline explicit QSignalBlocker(QObject &o) noexcept;
    inline ~QSignalBlocker();

    inline QSignalBlocker(QSignalBlocker &&other) noexcept;
    inline QSignalBlocker &operator=(QSignalBlocker &&other) noexcept;

    inline void reblock() noexcept;
    inline void unblock() noexcept;
private:
    QSignalBlocker(const QSignalBlocker &) = delete; QSignalBlocker &operator=(const QSignalBlocker &) = delete;
    QObject * m_o;
    bool m_blocked;
    bool m_inhibited;
};

QSignalBlocker::QSignalBlocker(QObject *o) noexcept
    : m_o(o),
      m_blocked(o && o->blockSignals(true)),
      m_inhibited(false)
{}

QSignalBlocker::QSignalBlocker(QObject &o) noexcept
    : m_o(&o),
      m_blocked(o.blockSignals(true)),
      m_inhibited(false)
{}

QSignalBlocker::QSignalBlocker(QSignalBlocker &&other) noexcept
    : m_o(other.m_o),
      m_blocked(other.m_blocked),
      m_inhibited(other.m_inhibited)
{
    other.m_o = nullptr;
}

QSignalBlocker &QSignalBlocker::operator=(QSignalBlocker &&other) noexcept
{
    if (this != &other) {
        
        
        if (m_o != other.m_o || (!m_inhibited && other.m_inhibited))
            unblock();
        m_o = other.m_o;
        m_blocked = other.m_blocked;
        m_inhibited = other.m_inhibited;
        
        other.m_o = nullptr;
    }
    return *this;
}

QSignalBlocker::~QSignalBlocker()
{
    if (m_o && !m_inhibited)
        m_o->blockSignals(m_blocked);
}

void QSignalBlocker::reblock() noexcept
{
    if (m_o) m_o->blockSignals(true);
    m_inhibited = false;
}

void QSignalBlocker::unblock() noexcept
{
    if (m_o) m_o->blockSignals(m_blocked);
    m_inhibited = true;
}

namespace QtPrivate {
    inline QObject & deref_for_methodcall(QObject &o) { return  o; }
    inline QObject & deref_for_methodcall(QObject *o) { return *o; }
}




#line 639 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"

#line 641 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qobject.h"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"



#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"









class QByteArray;
class QIODevicePrivate;

class __declspec(dllimport) QIODevice

    : public QObject
#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"
{

    public: __pragma(warning(push))  static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); virtual int qt_metacall(QMetaObject::Call, int, void **); static inline QString tr(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } __declspec(deprecated) static inline QString trUtf8(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } private:   static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); __pragma(warning(pop)) struct QPrivateSignal {}; 
#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"
public:
    enum OpenModeFlag {
        NotOpen = 0x0000,
        ReadOnly = 0x0001,
        WriteOnly = 0x0002,
        ReadWrite = ReadOnly | WriteOnly,
        Append = 0x0004,
        Truncate = 0x0008,
        Text = 0x0010,
        Unbuffered = 0x0020,
        NewOnly = 0x0040,
        ExistingOnly = 0x0080
    };
    typedef QFlags<OpenModeFlag> OpenMode;

    QIODevice();

    explicit QIODevice(QObject *parent);
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"
    virtual ~QIODevice();

    OpenMode openMode() const;

    void setTextModeEnabled(bool enabled);
    bool isTextModeEnabled() const;

    bool isOpen() const;
    bool isReadable() const;
    bool isWritable() const;
    virtual bool isSequential() const;

    int readChannelCount() const;
    int writeChannelCount() const;
    int currentReadChannel() const;
    void setCurrentReadChannel(int channel);
    int currentWriteChannel() const;
    void setCurrentWriteChannel(int channel);

    virtual bool open(OpenMode mode);
    virtual void close();

    
    
    virtual qint64 pos() const;
    virtual qint64 size() const;
    virtual bool seek(qint64 pos);
    virtual bool atEnd() const;
    virtual bool reset();

    virtual qint64 bytesAvailable() const;
    virtual qint64 bytesToWrite() const;

    qint64 read(char *data, qint64 maxlen);
    QByteArray read(qint64 maxlen);
    QByteArray readAll();
    qint64 readLine(char *data, qint64 maxlen);
    QByteArray readLine(qint64 maxlen = 0);
    virtual bool canReadLine() const;

    void startTransaction();
    void commitTransaction();
    void rollbackTransaction();
    bool isTransactionStarted() const;

    qint64 write(const char *data, qint64 len);
    qint64 write(const char *data);
    inline qint64 write(const QByteArray &data)
    { return write(data.constData(), data.size()); }

    qint64 peek(char *data, qint64 maxlen);
    QByteArray peek(qint64 maxlen);
    qint64 skip(qint64 maxSize);

    virtual bool waitForReadyRead(int msecs);
    virtual bool waitForBytesWritten(int msecs);

    void ungetChar(char c);
    bool putChar(char c);
    bool getChar(char *c);

    QString errorString() const;


public :
    void readyRead();
    void channelReadyRead(int channel);
    void bytesWritten(qint64 bytes);
    void channelBytesWritten(int channel, qint64 bytes);
    void aboutToClose();
    void readChannelFinished();
#line 161 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"

protected:



    QIODevice(QIODevicePrivate &dd, QObject *parent = nullptr);
#line 168 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"
    virtual qint64 readData(char *data, qint64 maxlen) = 0;
    virtual qint64 readLineData(char *data, qint64 maxlen);
    virtual qint64 writeData(const char *data, qint64 len) = 0;

    void setOpenMode(OpenMode openMode);

    void setErrorString(const QString &errorString);





private:
    inline QIODevicePrivate* d_func() { __pragma(warning(push))  return reinterpret_cast<QIODevicePrivate *>(qGetPtrHelper(d_ptr)); __pragma(warning(pop)) } inline const QIODevicePrivate* d_func() const { __pragma(warning(push))  return reinterpret_cast<const QIODevicePrivate *>(qGetPtrHelper(d_ptr)); __pragma(warning(pop)) } friend class QIODevicePrivate;
    QIODevice(const QIODevice &) = delete; QIODevice &operator=(const QIODevice &) = delete;
};

constexpr inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) noexcept { return QFlags<QIODevice::OpenMode::enum_type>(f1) | f2; } constexpr inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QFlags<QIODevice::OpenMode::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }


class QDebug;
__declspec(dllimport) QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);
#line 191 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"



#line 195 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qiodevice.h"
#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtextstream.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"






#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qstringlist.h"






























































































































































































































































































































































































































#pragma external_header(pop)
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbytearraylist.h"






























































































#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"


#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _Meta_list; 

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 171 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"

inline constexpr auto _Meta_npos = ~size_t{0};

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 <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 && ::std:: _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 ::std:: _Meta_find_unique_index_i_2(_Ptr, _Count, ::std:: _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> {
    static constexpr bool _Bools[] = {is_same_v<_First, _Ty>, is_same_v<_Rest, _Ty>...};
    using type = integral_constant<size_t, ::std:: _Meta_find_unique_index_i_(_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 suppress 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 suppress 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 suppress 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 suppress 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 367 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"
};

 inline constexpr size_t variant_npos = _Meta_npos;

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_cv_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_cv_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 ::std:: _Variant_raw_get<_Idx - 8>(
            static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
    } else if constexpr (_Idx < 32) {
        return ::std:: _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 ::std:: _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 ::std:: _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(::std:: _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>{::std:: _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[] = {
        &::std:: _Variant_raw_visit_valueless<_Fn, _Storage>, &::std:: _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)>{::std:: _Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{::std:: _Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{::std:: _Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{::std:: _Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{::std:: _Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{::std:: _Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{::std:: _Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4) + 1: if constexpr ((0 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4)>{::std:: _Variant_raw_get<(0 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 1) + 1: if constexpr ((0 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 1)>{::std:: _Variant_raw_get<(0 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 2) + 1: if constexpr ((0 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 2)>{::std:: _Variant_raw_get<(0 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 3) + 1: if constexpr ((0 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 3)>{::std:: _Variant_raw_get<(0 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8) + 1: if constexpr ((0 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8)>{::std:: _Variant_raw_get<(0 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 1) + 1: if constexpr ((0 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 1)>{::std:: _Variant_raw_get<(0 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 2) + 1: if constexpr ((0 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 2)>{::std:: _Variant_raw_get<(0 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 3) + 1: if constexpr ((0 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 3)>{::std:: _Variant_raw_get<(0 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12) + 1: if constexpr ((0 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12)>{::std:: _Variant_raw_get<(0 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 1) + 1: if constexpr ((0 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 1)>{::std:: _Variant_raw_get<(0 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 2) + 1: if constexpr ((0 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 2)>{::std:: _Variant_raw_get<(0 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 3) + 1: if constexpr ((0 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 3)>{::std:: _Variant_raw_get<(0 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{::std:: _Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{::std:: _Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{::std:: _Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4) + 1: if constexpr ((0 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4)>{::std:: _Variant_raw_get<(0 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 1) + 1: if constexpr ((0 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 1)>{::std:: _Variant_raw_get<(0 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 2) + 1: if constexpr ((0 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 2)>{::std:: _Variant_raw_get<(0 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 3) + 1: if constexpr ((0 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 3)>{::std:: _Variant_raw_get<(0 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8) + 1: if constexpr ((0 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8)>{::std:: _Variant_raw_get<(0 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 1) + 1: if constexpr ((0 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 1)>{::std:: _Variant_raw_get<(0 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 2) + 1: if constexpr ((0 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 2)>{::std:: _Variant_raw_get<(0 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 3) + 1: if constexpr ((0 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 3)>{::std:: _Variant_raw_get<(0 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12) + 1: if constexpr ((0 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12)>{::std:: _Variant_raw_get<(0 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 1) + 1: if constexpr ((0 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 1)>{::std:: _Variant_raw_get<(0 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 2) + 1: if constexpr ((0 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 2)>{::std:: _Variant_raw_get<(0 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 3) + 1: if constexpr ((0 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 3)>{::std:: _Variant_raw_get<(0 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16) + 1: if constexpr ((0 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16)>{::std:: _Variant_raw_get<(0 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 1) + 1: if constexpr ((0 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 1)>{::std:: _Variant_raw_get<(0 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 2) + 1: if constexpr ((0 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 2)>{::std:: _Variant_raw_get<(0 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 3) + 1: if constexpr ((0 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 3)>{::std:: _Variant_raw_get<(0 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 4) + 1: if constexpr ((0 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4)>{::std:: _Variant_raw_get<(0 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 8) + 1: if constexpr ((0 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8)>{::std:: _Variant_raw_get<(0 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 12) + 1: if constexpr ((0 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12)>{::std:: _Variant_raw_get<(0 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32) + 1: if constexpr ((0 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32)>{::std:: _Variant_raw_get<(0 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 1) + 1: if constexpr ((0 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 1)>{::std:: _Variant_raw_get<(0 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 2) + 1: if constexpr ((0 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 2)>{::std:: _Variant_raw_get<(0 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 3) + 1: if constexpr ((0 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 3)>{::std:: _Variant_raw_get<(0 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 4) + 1: if constexpr ((0 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4)>{::std:: _Variant_raw_get<(0 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 8) + 1: if constexpr ((0 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8)>{::std:: _Variant_raw_get<(0 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 12) + 1: if constexpr ((0 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12)>{::std:: _Variant_raw_get<(0 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48) + 1: if constexpr ((0 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48)>{::std:: _Variant_raw_get<(0 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 1) + 1: if constexpr ((0 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 1)>{::std:: _Variant_raw_get<(0 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 2) + 1: if constexpr ((0 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 2)>{::std:: _Variant_raw_get<(0 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 3) + 1: if constexpr ((0 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 3)>{::std:: _Variant_raw_get<(0 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 4) + 1: if constexpr ((0 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4)>{::std:: _Variant_raw_get<(0 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 8) + 1: if constexpr ((0 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8)>{::std:: _Variant_raw_get<(0 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 12) + 1: if constexpr ((0 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12)>{::std:: _Variant_raw_get<(0 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{::std:: _Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{::std:: _Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{::std:: _Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4) + 1: if constexpr ((0 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4)>{::std:: _Variant_raw_get<(0 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 1) + 1: if constexpr ((0 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 1)>{::std:: _Variant_raw_get<(0 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 2) + 1: if constexpr ((0 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 2)>{::std:: _Variant_raw_get<(0 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 4 + 3) + 1: if constexpr ((0 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 3)>{::std:: _Variant_raw_get<(0 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8) + 1: if constexpr ((0 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8)>{::std:: _Variant_raw_get<(0 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 1) + 1: if constexpr ((0 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 1)>{::std:: _Variant_raw_get<(0 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 2) + 1: if constexpr ((0 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 2)>{::std:: _Variant_raw_get<(0 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 8 + 3) + 1: if constexpr ((0 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 3)>{::std:: _Variant_raw_get<(0 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12) + 1: if constexpr ((0 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12)>{::std:: _Variant_raw_get<(0 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 1) + 1: if constexpr ((0 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 1)>{::std:: _Variant_raw_get<(0 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 2) + 1: if constexpr ((0 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 2)>{::std:: _Variant_raw_get<(0 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 12 + 3) + 1: if constexpr ((0 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 3)>{::std:: _Variant_raw_get<(0 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16) + 1: if constexpr ((0 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16)>{::std:: _Variant_raw_get<(0 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 1) + 1: if constexpr ((0 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 1)>{::std:: _Variant_raw_get<(0 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 2) + 1: if constexpr ((0 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 2)>{::std:: _Variant_raw_get<(0 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 3) + 1: if constexpr ((0 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 3)>{::std:: _Variant_raw_get<(0 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 4) + 1: if constexpr ((0 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4)>{::std:: _Variant_raw_get<(0 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 8) + 1: if constexpr ((0 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8)>{::std:: _Variant_raw_get<(0 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 16 + 12) + 1: if constexpr ((0 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12)>{::std:: _Variant_raw_get<(0 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32) + 1: if constexpr ((0 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32)>{::std:: _Variant_raw_get<(0 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 1) + 1: if constexpr ((0 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 1)>{::std:: _Variant_raw_get<(0 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 2) + 1: if constexpr ((0 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 2)>{::std:: _Variant_raw_get<(0 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 3) + 1: if constexpr ((0 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 3)>{::std:: _Variant_raw_get<(0 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 4) + 1: if constexpr ((0 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4)>{::std:: _Variant_raw_get<(0 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 8) + 1: if constexpr ((0 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8)>{::std:: _Variant_raw_get<(0 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 32 + 12) + 1: if constexpr ((0 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12)>{::std:: _Variant_raw_get<(0 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48) + 1: if constexpr ((0 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48)>{::std:: _Variant_raw_get<(0 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 1) + 1: if constexpr ((0 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 1)>{::std:: _Variant_raw_get<(0 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 2) + 1: if constexpr ((0 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 2)>{::std:: _Variant_raw_get<(0 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 3) + 1: if constexpr ((0 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 3)>{::std:: _Variant_raw_get<(0 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 4) + 1: if constexpr ((0 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4)>{::std:: _Variant_raw_get<(0 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 8) + 1: if constexpr ((0 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8)>{::std:: _Variant_raw_get<(0 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 48 + 12) + 1: if constexpr ((0 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12)>{::std:: _Variant_raw_get<(0 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64) + 1: if constexpr ((0 + 64) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64)>{::std:: _Variant_raw_get<(0 + 64)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 1) + 1: if constexpr ((0 + 64 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 1)>{::std:: _Variant_raw_get<(0 + 64 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 2) + 1: if constexpr ((0 + 64 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 2)>{::std:: _Variant_raw_get<(0 + 64 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 3) + 1: if constexpr ((0 + 64 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 3)>{::std:: _Variant_raw_get<(0 + 64 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 4) + 1: if constexpr ((0 + 64 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 4)>{::std:: _Variant_raw_get<(0 + 64 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 8) + 1: if constexpr ((0 + 64 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 8)>{::std:: _Variant_raw_get<(0 + 64 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 12) + 1: if constexpr ((0 + 64 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 12)>{::std:: _Variant_raw_get<(0 + 64 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 16) + 1: if constexpr ((0 + 64 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16)>{::std:: _Variant_raw_get<(0 + 64 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 32) + 1: if constexpr ((0 + 64 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32)>{::std:: _Variant_raw_get<(0 + 64 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 64 + 48) + 1: if constexpr ((0 + 64 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48)>{::std:: _Variant_raw_get<(0 + 64 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 64 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128) + 1: if constexpr ((0 + 128) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128)>{::std:: _Variant_raw_get<(0 + 128)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 1) + 1: if constexpr ((0 + 128 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 1)>{::std:: _Variant_raw_get<(0 + 128 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 2) + 1: if constexpr ((0 + 128 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 2)>{::std:: _Variant_raw_get<(0 + 128 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 3) + 1: if constexpr ((0 + 128 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 3)>{::std:: _Variant_raw_get<(0 + 128 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 4) + 1: if constexpr ((0 + 128 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 4)>{::std:: _Variant_raw_get<(0 + 128 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 8) + 1: if constexpr ((0 + 128 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 8)>{::std:: _Variant_raw_get<(0 + 128 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 12) + 1: if constexpr ((0 + 128 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 12)>{::std:: _Variant_raw_get<(0 + 128 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 16) + 1: if constexpr ((0 + 128 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16)>{::std:: _Variant_raw_get<(0 + 128 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 32) + 1: if constexpr ((0 + 128 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32)>{::std:: _Variant_raw_get<(0 + 128 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 128 + 48) + 1: if constexpr ((0 + 128 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48)>{::std:: _Variant_raw_get<(0 + 128 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 128 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192) + 1: if constexpr ((0 + 192) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192)>{::std:: _Variant_raw_get<(0 + 192)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 1) + 1: if constexpr ((0 + 192 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 1)>{::std:: _Variant_raw_get<(0 + 192 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 2) + 1: if constexpr ((0 + 192 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 2)>{::std:: _Variant_raw_get<(0 + 192 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 3) + 1: if constexpr ((0 + 192 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 3)>{::std:: _Variant_raw_get<(0 + 192 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 4) + 1: if constexpr ((0 + 192 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 4)>{::std:: _Variant_raw_get<(0 + 192 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 8) + 1: if constexpr ((0 + 192 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 8)>{::std:: _Variant_raw_get<(0 + 192 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 12) + 1: if constexpr ((0 + 192 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 12)>{::std:: _Variant_raw_get<(0 + 192 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 16) + 1: if constexpr ((0 + 192 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16)>{::std:: _Variant_raw_get<(0 + 192 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 32) + 1: if constexpr ((0 + 192 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32)>{::std:: _Variant_raw_get<(0 + 192 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; case (0 + 192 + 48) + 1: if constexpr ((0 + 192 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48)>{::std:: _Variant_raw_get<(0 + 192 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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)>{::std:: _Variant_raw_get<(0 + 192 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); [[fallthrough]]; 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;

inline constexpr size_t _Schar_max_as_size = static_cast<unsigned char>(-1) / 2;
inline constexpr size_t _Short_max_as_size = static_cast<unsigned short>(-1) / 2;

template <size_t _Count>
using _Variant_index_t = 
    conditional_t<(_Count < _Schar_max_as_size), signed char, conditional_t<(_Count < _Short_max_as_size), 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) {
            ::std:: _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 = ::std:: _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();
                        ::std:: _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, _Source._Val);
                    } else { 
                        auto _Temp = _Source._Val;
                        _Self._Reset();
                        ::std:: _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, ::std:: move(_Temp));
                    }
                } else { 
                    _Self._Reset();
                    ::std:: _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 {
        
        
        using _Indexed_value_type = remove_cv_t<_Meta_at_c<variant<_Types...>, _Idx>>;
        if constexpr (_Idx != variant_npos && !is_trivially_destructible_v<_Indexed_value_type>) {
            ::std:: _Variant_raw_get<_Idx>(_Storage()).~_Indexed_value_type();
        }
    }

    constexpr void _Destroy() noexcept { 
        if constexpr (!conjunction_v<is_trivially_destructible<_Types>...>) {
            ::std:: _Variant_raw_visit(index(), _Storage(), [](auto _Ref) noexcept {
                if constexpr (decltype(_Ref)::_Idx != variant_npos) {
                    using _Indexed_value_type = _Remove_cvref_t<decltype(_Ref._Val)>;
                    _Ref._Val.~_Indexed_value_type();
                }
            });
        }
    }

    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>...>) {
        
        
        ::std:: _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>...>) {
        
        
        ::std:: _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>...>) {
        
        ::std:: _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>...>) {
        
        ::std:: _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 904 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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(::std:: _Construct_array<_Idx, _TargetType>({::std:: declval<_InitializerType>()}));
#line 913 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 923 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 959 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "
        "(N4950 [variant.variant.general]/2).");
    static_assert(sizeof...(_Types) > 0,
        "variant<> (with no template arguments) may not be instantiated (N4950 [variant.variant.general]/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 = ::std:: _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. (N4950 [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. (N4950 [variant.swap]/2)");
        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) {
            
            ::std:: _Variant_raw_visit(index(), _Storage(),
                [this, &_That](auto _My_ref) noexcept(
                    conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
                    ::std:: _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;
                            if constexpr (_My_idx == _That_idx) { 
                                if constexpr (_My_idx != variant_npos) { 
                                    using ::std:: swap;
                                    swap(_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);
                                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) {
                ::std:: _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) {
                            using ::std:: swap;
                            swap(_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...>) {
        
        ;
        ::std:: _Construct_in_place(_Storage(), integral_constant<size_t, _Idx>{}, static_cast<_ArgTypes&&>(_Args)...);
        this->_Set_index(_Idx);
        return ::std:: _Variant_raw_get<_Idx>(_Storage());
    }

    constexpr void _Emplace_from(variant&& _That) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
        
        this->_Reset();
        ::std:: _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. (N4950 [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 ::std:: _Variant_raw_get<_Idx>(_Var._Storage());
    }

    ::std:: _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 ::std:: _Variant_raw_get<_Idx>(::std:: move(_Var)._Storage());
    }

    ::std:: _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 ::std:: _Variant_raw_get<_Idx>(_Var._Storage());
    }

    ::std:: _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 ::std:: _Variant_raw_get<_Idx>(::std:: move(_Var)._Storage());
    }

    ::std:: _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. (N4950 [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. (N4950 [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. (N4950 [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. (N4950 [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(::std:: _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(::std:: _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. (N4950 [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. (N4950 [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{}(::std:: _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
        && ::std:: _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
        || ::std:: _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
            && ::std:: _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
            && ::std:: _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
            && ::std:: _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
            && ::std:: _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
             : ::std:: _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()});
}
#line 1401 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 ::std:: _Variant_visit_index1(_Acc, _Rest...);
}

template <class _Callable, class... _Types>
using _Variant_visit_result_t =
    decltype(::std:: invoke(::std:: declval<_Callable>(), ::std:: _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, ...); 
            ::std:: _Throw_bad_variant_access();
        }

        else if constexpr (is_void_v<_Ret>) {
            static_cast<void>(::std:: invoke(static_cast<_Callable&&>(_Obj),
                ::std:: _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...));
        }
#line 1438 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"
        else {
            return ::std:: invoke(static_cast<_Callable&&>(_Obj),
                ::std:: _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 <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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; 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); [[fallthrough]]; default: __assume(false); };
    }
};




template <class... _Types>
variant<_Types...>& _As_variant_impl(variant<_Types...>&);
template <class... _Types>
const variant<_Types...>& _As_variant_impl(const variant<_Types...>&);
template <class... _Types>
variant<_Types...>&& _As_variant_impl(variant<_Types...>&&);
template <class... _Types>
const variant<_Types...>&& _As_variant_impl(const variant<_Types...>&&);
template <class _Ty>
using _As_variant = 
    decltype(::std:: _As_variant_impl(::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>(
        ::std:: _Variant_visit_index1(0, static_cast<_As_variant<_Variants>&>(_Args)...), static_cast<_Callable&&>(_Obj),
        static_cast<_As_variant<_Variants>&&>(_Args)...);
}

template <class _Expected, class _Callable, class _ArgList, class... _Variants>
inline constexpr bool _Variant_all_visit_results_same = false;

template <class _Expected, class _Callable, class... _Args>
inline constexpr bool _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>> =
    is_same_v<decltype(::std:: invoke(::std:: declval<_Callable>(), ::std:: declval<_Args>()...)), _Expected>;

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool
    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool
    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&, _Rest...> =
        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...> && ...);

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool
    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool
    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&&, _Rest...> =
        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);

 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<_Ret, _Callable, _Meta_list<>, _As_variant<_Variants>...>,
        "visit() requires the result of all potential invocations to have the same type and value category "
        "(N4950 [variant.visit]/5).");

    return ::std:: _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
}


template <class _Expected, class _Callable, class _ArgList, class... _Variants>
inline constexpr bool _Variant_all_visit_results_convertible = false;

template <class _Expected, class _Callable, class... _Args>
inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>> =
    _Invoke_convertible<decltype(::std:: invoke(::std:: declval<_Callable>(), ::std:: declval<_Args>()...)), _Expected>::value;

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool
    _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
        (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
    const variant<_Types...>&, _Rest...> =
    (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...>
        && ...);

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool
    _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
        (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);

template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
    const variant<_Types...>&&, _Rest...> =
    (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);

 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_convertible<_Ret, _Callable, _Meta_list<>, _As_variant<_Variants>...>,
            "visit<R>() requires the result of all potential invocations to be implicitly convertible to R "
            "(N4950 [variant.visit]/5).");
    }

    return ::std:: _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
}
#line 1658 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"

 [[nodiscard]] constexpr bool operator==(monostate, monostate) noexcept {
    return true;
}


 [[nodiscard]] constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
    return strong_ordering::equal;
}
















#line 1684 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 ::std:: _Variant_raw_visit(_Var.index(), _Var._Storage(), _Variant_hash_visitor{});
    }
};

template <>
struct hash<monostate> {
    using _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 suppress this warning.")]] = monostate;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[nodiscard]] size_t operator()(monostate) const noexcept {
        return 1729; 
    }
};

}









#pragma warning(pop)
#pragma pack(pop)
#line 1737 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"
#line 1738 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"
#line 1739 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\variant"
#pragma external_header(pop)
#line 58 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"


#line 61 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"




class QBitArray;
class QDataStream;
class QDate;
class QDateTime;

class QEasingCurve;
#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
class QLine;
class QLineF;
class QLocale;
class QMatrix;
class QTransform;
class QStringList;
class QTime;
class QPoint;
class QPointF;
class QSize;
class QSizeF;
class QRect;
class QRectF;

class QRegExp;
#line 88 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

class QRegularExpression;
#line 91 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
class QTextFormat;
class QTextLength;
class QUrl;
class QVariant;
class QVariantComparisonHelper;

template<typename T>
inline T qvariant_cast(const QVariant &);

namespace QtPrivate {

    template <typename Derived, typename Argument, typename ReturnType>
    struct ObjectInvoker
    {
        static ReturnType invoke(Argument a)
        {
            return Derived::object(a);
        }
    };

    template <typename Derived, typename Argument, typename ReturnType>
    struct MetaTypeInvoker
    {
        static ReturnType invoke(Argument a)
        {
            return Derived::metaType(a);
        }
    };

    template <typename Derived, typename T, typename Argument, typename ReturnType, bool = IsPointerToTypeDerivedFromQObject<T>::Value>
    struct TreatAsQObjectBeforeMetaType : ObjectInvoker<Derived, Argument, ReturnType>
    {
    };

    template <typename Derived, typename T, typename Argument, typename ReturnType>
    struct TreatAsQObjectBeforeMetaType<Derived, T, Argument, ReturnType, false> : MetaTypeInvoker<Derived, Argument, ReturnType>
    {
    };

    template<typename T> struct QVariantValueHelper;
}

class __declspec(dllimport) QVariant
{
 public:
    enum Type {
        Invalid = QMetaType::UnknownType,
        Bool = QMetaType::Bool,
        Int = QMetaType::Int,
        UInt = QMetaType::UInt,
        LongLong = QMetaType::LongLong,
        ULongLong = QMetaType::ULongLong,
        Double = QMetaType::Double,
        Char = QMetaType::QChar,
        Map = QMetaType::QVariantMap,
        List = QMetaType::QVariantList,
        String = QMetaType::QString,
        StringList = QMetaType::QStringList,
        ByteArray = QMetaType::QByteArray,
        BitArray = QMetaType::QBitArray,
        Date = QMetaType::QDate,
        Time = QMetaType::QTime,
        DateTime = QMetaType::QDateTime,
        Url = QMetaType::QUrl,
        Locale = QMetaType::QLocale,
        Rect = QMetaType::QRect,
        RectF = QMetaType::QRectF,
        Size = QMetaType::QSize,
        SizeF = QMetaType::QSizeF,
        Line = QMetaType::QLine,
        LineF = QMetaType::QLineF,
        Point = QMetaType::QPoint,
        PointF = QMetaType::QPointF,
        RegExp = QMetaType::QRegExp,
        RegularExpression = QMetaType::QRegularExpression,
        Hash = QMetaType::QVariantHash,

        EasingCurve = QMetaType::QEasingCurve,
#line 170 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
        Uuid = QMetaType::QUuid,

        ModelIndex = QMetaType::QModelIndex,
        PersistentModelIndex = QMetaType::QPersistentModelIndex,
#line 175 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
        LastCoreType = QMetaType::LastCoreType,

        Font = QMetaType::QFont,
        Pixmap = QMetaType::QPixmap,
        Brush = QMetaType::QBrush,
        Color = QMetaType::QColor,
        Palette = QMetaType::QPalette,
        Image = QMetaType::QImage,
        Polygon = QMetaType::QPolygon,
        Region = QMetaType::QRegion,
        Bitmap = QMetaType::QBitmap,
        Cursor = QMetaType::QCursor,
        KeySequence = QMetaType::QKeySequence,
        Pen = QMetaType::QPen,
        TextLength = QMetaType::QTextLength,
        TextFormat = QMetaType::QTextFormat,
        Matrix = QMetaType::QMatrix,
        Transform = QMetaType::QTransform,
        Matrix4x4 = QMetaType::QMatrix4x4,
        Vector2D = QMetaType::QVector2D,
        Vector3D = QMetaType::QVector3D,
        Vector4D = QMetaType::QVector4D,
        Quaternion = QMetaType::QQuaternion,
        PolygonF = QMetaType::QPolygonF,
        Icon = QMetaType::QIcon,
        LastGuiType = QMetaType::LastGuiType,

        SizePolicy = QMetaType::QSizePolicy,

        UserType = QMetaType::User,
        LastType = 0xffffffff 
    };

    QVariant() noexcept : d() {}
    ~QVariant();
    QVariant(Type type);
    QVariant(int typeId, const void *copy);
    QVariant(int typeId, const void *copy, uint flags);
    QVariant(const QVariant &other);


    QVariant(QDataStream &s);
#line 218 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QVariant(int i);
    QVariant(uint ui);
    QVariant(qlonglong ll);
    QVariant(qulonglong ull);
    QVariant(bool b);
    QVariant(double d);
    QVariant(float f);

     QVariant(const char *str);
#line 229 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QVariant(const QByteArray &bytearray);
    QVariant(const QBitArray &bitarray);
    QVariant(const QString &string);
    QVariant(QLatin1String string);
    QVariant(const QStringList &stringlist);
    QVariant(QChar qchar);
    QVariant(const QDate &date);
    QVariant(const QTime &time);
    QVariant(const QDateTime &datetime);
    QVariant(const QList<QVariant> &list);
    QVariant(const QMap<QString,QVariant> &map);
    QVariant(const QHash<QString,QVariant> &hash);

    QVariant(const QSize &size);
    QVariant(const QSizeF &size);
    QVariant(const QPoint &pt);
    QVariant(const QPointF &pt);
    QVariant(const QLine &line);
    QVariant(const QLineF &line);
    QVariant(const QRect &rect);
    QVariant(const QRectF &rect);
#line 252 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    QVariant(const QLocale &locale);

    QVariant(const QRegExp &regExp);
#line 256 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QVariant(const QRegularExpression &re);
#line 259 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QVariant(const QEasingCurve &easing);
#line 262 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    QVariant(const QUuid &uuid);

    QVariant(const QUrl &url);
    QVariant(const QJsonValue &jsonValue);
    QVariant(const QJsonObject &jsonObject);
    QVariant(const QJsonArray &jsonArray);
    QVariant(const QJsonDocument &jsonDocument);
#line 270 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QVariant(const QModelIndex &modelIndex);
    QVariant(const QPersistentModelIndex &modelIndex);
#line 274 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QVariant& operator=(const QVariant &other);
    inline QVariant(QVariant &&other) noexcept : d(other.d)
    { other.d = Private(); }
    inline QVariant &operator=(QVariant &&other) noexcept
    { qSwap(d, other.d); return *this; }

    inline void swap(QVariant &other) noexcept { qSwap(d, other.d); }

    Type type() const;
    int userType() const;
    const char *typeName() const;

    bool canConvert(int targetTypeId) const;
    bool convert(int targetTypeId);

    inline bool isValid() const;
    bool isNull() const;

    void clear();

    void detach();
    inline bool isDetached() const;

    int toInt(bool *ok = nullptr) const;
    uint toUInt(bool *ok = nullptr) const;
    qlonglong toLongLong(bool *ok = nullptr) const;
    qulonglong toULongLong(bool *ok = nullptr) const;
    bool toBool() const;
    double toDouble(bool *ok = nullptr) const;
    float toFloat(bool *ok = nullptr) const;
    qreal toReal(bool *ok = nullptr) const;
    QByteArray toByteArray() const;
    QBitArray toBitArray() const;
    QString toString() const;
    QStringList toStringList() const;
    QChar toChar() const;
    QDate toDate() const;
    QTime toTime() const;
    QDateTime toDateTime() const;
    QList<QVariant> toList() const;
    QMap<QString, QVariant> toMap() const;
    QHash<QString, QVariant> toHash() const;


    QPoint toPoint() const;
    QPointF toPointF() const;
    QRect toRect() const;
    QSize toSize() const;
    QSizeF toSizeF() const;
    QLine toLine() const;
    QLineF toLineF() const;
    QRectF toRectF() const;
#line 328 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    QLocale toLocale() const;

    QRegExp toRegExp() const;
#line 332 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QRegularExpression toRegularExpression() const;
#line 335 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QEasingCurve toEasingCurve() const;
#line 338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    QUuid toUuid() const;

    QUrl toUrl() const;
    QJsonValue toJsonValue() const;
    QJsonObject toJsonObject() const;
    QJsonArray toJsonArray() const;
    QJsonDocument toJsonDocument() const;
#line 346 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    QModelIndex toModelIndex() const;
    QPersistentModelIndex toPersistentModelIndex() const;
#line 350 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"


    void load(QDataStream &ds);
    void save(QDataStream &ds) const;
#line 355 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    static const char *typeToName(int typeId);
    static Type nameToType(const char *name);

    void *data();
    const void *constData() const;
    inline const void *data() const { return constData(); }

    template<typename T>
    inline void setValue(const T &value);

    template<typename T>
    inline T value() const
    { return qvariant_cast<T>(*this); }

    template<typename T>
    static inline QVariant fromValue(const T &value)
    { return QVariant(qMetaTypeId<T>(), &value, QTypeInfo<T>::isPointer); }


    template<typename... Types>
    static inline QVariant fromStdVariant(const std::variant<Types...> &value)
    {
        if (value.valueless_by_exception())
            return QVariant();
        return std::visit([](const auto &arg) { return fromValue(arg); }, value);
    }
#line 382 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    template<typename T>
    bool canConvert() const
    { return canConvert(qMetaTypeId<T>()); }

 public:
    struct PrivateShared
    {
        inline PrivateShared(void *v) : ptr(v), ref(1) { }
        void *ptr;
        QAtomicInt ref;
    };
    struct Private
    {
        inline Private() noexcept : type(Invalid), is_shared(false), is_null(true)
        { data.ptr = nullptr; }

        
        explicit inline Private(uint variantType) noexcept
            : type(variantType), is_shared(false), is_null(false)
        {}


        Private(const Private &other) noexcept
            : data(other.data), type(other.type),
              is_shared(other.is_shared), is_null(other.is_null)
        {}
        Private &operator=(const Private &other) noexcept = default;
#line 411 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
        union Data
        {
            char c;
            uchar uc;
            short s;
            signed char sc;
            ushort us;
            int i;
            uint u;
            long l;
            ulong ul;
            bool b;
            double d;
            float f;
            qreal real;
            qlonglong ll;
            qulonglong ull;
            QObject *o;
            void *ptr;
            PrivateShared *shared;
        } data;
        uint type : 30;
        uint is_shared : 1;
        uint is_null : 1;
    };
 public:
    typedef void (*f_construct)(Private *, const void *);
    typedef void (*f_clear)(Private *);
    typedef bool (*f_null)(const Private *);

    typedef void (*f_load)(Private *, QDataStream &);
    typedef void (*f_save)(const Private *, QDataStream &);
#line 444 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    typedef bool (*f_compare)(const Private *, const Private *);
    typedef bool (*f_convert)(const QVariant::Private *d, int t, void *, bool *);
    typedef bool (*f_canConvert)(const QVariant::Private *d, int t);
    typedef void (*f_debugStream)(QDebug, const QVariant &);
    struct Handler {
        f_construct construct;
        f_clear clear;
        f_null isNull;

        f_load load;
        f_save save;
#line 456 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
        f_compare compare;
        f_convert convert;
        f_canConvert canConvert;
        f_debugStream debugStream;
    };

    inline bool operator==(const QVariant &v) const
    { return cmp(v); }
    inline bool operator!=(const QVariant &v) const
    { return !cmp(v); }









#line 476 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

protected:
    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);

    friend __declspec(dllimport) QDebug operator<<(QDebug, const QVariant &);
#line 482 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"






#line 489 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
public:
#line 491 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    Private d;
    void create(int type, const void *copy);
    bool cmp(const QVariant &other) const;
    int compare(const QVariant &other) const;
    bool convert(const int t, void *ptr) const; 

private:
    
    inline QVariant(void *) = delete;
    
    
    
    
    
    
    QVariant(QMetaType::Type) = delete;

    
    
    
    
    
    QVariant(Qt::GlobalColor) = delete;
    QVariant(Qt::BrushStyle) = delete;
    QVariant(Qt::PenStyle) = delete;
    QVariant(Qt::CursorShape) = delete;




public:
    typedef Private DataPtr;
    inline DataPtr &data_ptr() { return d; }
    inline const DataPtr &data_ptr() const { return d; }
};















#line 542 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

template<>
inline QVariant QVariant::fromValue(const QVariant &value)
{
    return value;
}


template<>
inline QVariant QVariant::fromValue(const std::monostate &)
{
    return QVariant();
}
#line 556 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

inline bool QVariant::isValid() const { return d.type != Invalid; }

template<typename T>
inline void QVariant::setValue(const T &avalue)
{
    
    const uint type = qMetaTypeId<T>();
    if (isDetached() && (type == d.type || (type <= uint(QVariant::Char) && d.type <= uint(QVariant::Char)))) {
        d.type = type;
        d.is_null = false;
        T *old = reinterpret_cast<T*>(d.is_shared ? d.data.shared->ptr : &d.data.ptr);
        if (QTypeInfo<T>::isComplex)
            old->~T();
        new (old) T(avalue); 
    } else {
        *this = QVariant(type, &avalue, QTypeInfo<T>::isPointer);
    }
}

template<>
inline void QVariant::setValue(const QVariant &avalue)
{
    *this = avalue;
}


__declspec(dllimport) QDataStream& operator>> (QDataStream& s, QVariant& p);
__declspec(dllimport) QDataStream& operator<< (QDataStream& s, const QVariant& p);
__declspec(dllimport) QDataStream& operator>> (QDataStream& s, QVariant::Type& p);
__declspec(dllimport) QDataStream& operator<< (QDataStream& s, const QVariant::Type p);
#line 588 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

inline bool QVariant::isDetached() const
{ return !d.is_shared || d.data.shared->ref.loadRelaxed() == 1; }










class QVariantComparisonHelper
{
public:
    inline QVariantComparisonHelper(const QVariant &var)
        : v(&var) {}
private:
    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
    const QVariant *v;
};

inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2)
{
    return v1.cmp(*v2.v);
}

inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2)
{
    return !operator==(v1, v2);
}
#line 621 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
template<> class QTypeInfo<QVariant > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QVariant>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QVariant>(), isLarge = (sizeof(QVariant)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QVariant >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QVariant) }; static inline const char *name() { return "QVariant"; } }; inline void swap(QVariant &value1, QVariant &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }

class __declspec(dllimport) QSequentialIterable
{
    QtMetaTypePrivate::QSequentialIterableImpl m_impl;
public:
    struct __declspec(dllimport) const_iterator
    {
    private:
        QtMetaTypePrivate::QSequentialIterableImpl m_impl;
        QAtomicInt *ref;
        friend class QSequentialIterable;
        explicit const_iterator(const QSequentialIterable &iter, QAtomicInt *ref_);

        explicit const_iterator(const QtMetaTypePrivate::QSequentialIterableImpl &impl, QAtomicInt *ref_);

        void begin();
        void end();
    public:
        ~const_iterator();

        const_iterator(const const_iterator &other);

        const_iterator& operator=(const const_iterator &other);

        const QVariant operator*() const;
        bool operator==(const const_iterator &o) const;
        bool operator!=(const const_iterator &o) const;
        const_iterator &operator++();
        const_iterator operator++(int);
        const_iterator &operator--();
        const_iterator operator--(int);
        const_iterator &operator+=(int j);
        const_iterator &operator-=(int j);
        const_iterator operator+(int j) const;
        const_iterator operator-(int j) const;
        friend inline const_iterator operator+(int j, const_iterator k) { return k + j; }
    };

    friend struct const_iterator;


    explicit QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl impl);


#line 667 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    const_iterator begin() const;
    const_iterator end() const;

    QVariant at(int idx) const;
    int size() const;

    bool canReverseIterate() const;
};

class __declspec(dllimport) QAssociativeIterable
{
    QtMetaTypePrivate::QAssociativeIterableImpl m_impl;
public:
    struct __declspec(dllimport) const_iterator
    {
    private:
        QtMetaTypePrivate::QAssociativeIterableImpl m_impl;
        QAtomicInt *ref;
        friend class QAssociativeIterable;
        explicit const_iterator(const QAssociativeIterable &iter, QAtomicInt *ref_);

        explicit const_iterator(const QtMetaTypePrivate::QAssociativeIterableImpl &impl, QAtomicInt *ref_);

        void begin();
        void end();
        void find(const QVariant &key);
    public:
        ~const_iterator();
        const_iterator(const const_iterator &other);

        const_iterator& operator=(const const_iterator &other);

        const QVariant key() const;

        const QVariant value() const;

        const QVariant operator*() const;
        bool operator==(const const_iterator &o) const;
        bool operator!=(const const_iterator &o) const;
        const_iterator &operator++();
        const_iterator operator++(int);
        const_iterator &operator--();
        const_iterator operator--(int);
        const_iterator &operator+=(int j);
        const_iterator &operator-=(int j);
        const_iterator operator+(int j) const;
        const_iterator operator-(int j) const;
        friend inline const_iterator operator+(int j, const_iterator k) { return k + j; }
    };

    friend struct const_iterator;


    explicit QAssociativeIterable(QtMetaTypePrivate::QAssociativeIterableImpl impl);


#line 725 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

    const_iterator begin() const;
    const_iterator end() const;
    const_iterator find(const QVariant &key) const;

    QVariant value(const QVariant &key) const;

    int size() const;
};


namespace QtPrivate {
    template<typename T>
    struct QVariantValueHelper : TreatAsQObjectBeforeMetaType<QVariantValueHelper<T>, T, const QVariant &, T>
    {
        static T metaType(const QVariant &v)
        {
            const int vid = qMetaTypeId<T>();
            if (vid == v.userType())
                return *reinterpret_cast<const T *>(v.constData());
            T t;
            if (v.convert(vid, &t))
                return t;
            return T();
        }

        static T object(const QVariant &v)
        {
            return qobject_cast<T>(QMetaType::typeFlags(v.userType()) & QMetaType::PointerToQObject
                ? v.d.data.o
                : QVariantValueHelper::metaType(v));
        }
#line 758 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
    };

    template<typename T>
    struct QVariantValueHelperInterface : QVariantValueHelper<T>
    {
    };

    template<>
    struct QVariantValueHelperInterface<QSequentialIterable>
    {
        static QSequentialIterable invoke(const QVariant &v)
        {
            const int typeId = v.userType();
            if (typeId == qMetaTypeId<QVariantList>()) {
                return QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl(reinterpret_cast<const QVariantList*>(v.constData())));
            }
            if (typeId == qMetaTypeId<QStringList>()) {
                return QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl(reinterpret_cast<const QStringList*>(v.constData())));
            }

            if (typeId == qMetaTypeId<QByteArrayList>()) {
                return QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl(reinterpret_cast<const QByteArrayList*>(v.constData())));
            }
#line 782 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
            return QSequentialIterable(qvariant_cast<QtMetaTypePrivate::QSequentialIterableImpl>(v));
        }
    };
    template<>
    struct QVariantValueHelperInterface<QAssociativeIterable>
    {
        static QAssociativeIterable invoke(const QVariant &v)
        {
            const int typeId = v.userType();
            if (typeId == qMetaTypeId<QVariantMap>()) {
                return QAssociativeIterable(QtMetaTypePrivate::QAssociativeIterableImpl(reinterpret_cast<const QVariantMap*>(v.constData())));
            }
            if (typeId == qMetaTypeId<QVariantHash>()) {
                return QAssociativeIterable(QtMetaTypePrivate::QAssociativeIterableImpl(reinterpret_cast<const QVariantHash*>(v.constData())));
            }
            return QAssociativeIterable(qvariant_cast<QtMetaTypePrivate::QAssociativeIterableImpl>(v));
        }
    };
    template<>
    struct QVariantValueHelperInterface<QVariantList>
    {
        static QVariantList invoke(const QVariant &v)
        {
            const int typeId = v.userType();
            if (typeId == qMetaTypeId<QStringList>() || typeId == qMetaTypeId<QByteArrayList>() ||
                (QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QSequentialIterableImpl>()) && !QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QVariantList>()))) {
                QSequentialIterable iter = QVariantValueHelperInterface<QSequentialIterable>::invoke(v);
                QVariantList l;
                l.reserve(iter.size());
                for (QSequentialIterable::const_iterator it = iter.begin(), end = iter.end(); it != end; ++it)
                    l << *it;
                return l;
            }
            return QVariantValueHelper<QVariantList>::invoke(v);
        }
    };
    template<>
    struct QVariantValueHelperInterface<QVariantHash>
    {
        static QVariantHash invoke(const QVariant &v)
        {
            const int typeId = v.userType();
            if (typeId == qMetaTypeId<QVariantMap>() || ((QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>())) && !QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QVariantHash>()))) {
                QAssociativeIterable iter = QVariantValueHelperInterface<QAssociativeIterable>::invoke(v);
                QVariantHash l;
                l.reserve(iter.size());
                for (QAssociativeIterable::const_iterator it = iter.begin(), end = iter.end(); it != end; ++it)
                    static_cast<QMultiHash<QString, QVariant> &>(l).insert(it.key().toString(), it.value());
                return l;
            }
            return QVariantValueHelper<QVariantHash>::invoke(v);
        }
    };
    template<>
    struct QVariantValueHelperInterface<QVariantMap>
    {
        static QVariantMap invoke(const QVariant &v)
        {
            const int typeId = v.userType();
            if (typeId == qMetaTypeId<QVariantHash>() || (QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>()) && !QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QVariantMap>()))) {
                QAssociativeIterable iter = QVariantValueHelperInterface<QAssociativeIterable>::invoke(v);
                QVariantMap l;
                for (QAssociativeIterable::const_iterator it = iter.begin(), end = iter.end(); it != end; ++it)
                    static_cast<QMultiMap<QString, QVariant> &>(l).insert(it.key().toString(), it.value());
                return l;
            }
            return QVariantValueHelper<QVariantMap>::invoke(v);
        }
    };
    template<>
    struct QVariantValueHelperInterface<QPair<QVariant, QVariant> >
    {
        static QPair<QVariant, QVariant> invoke(const QVariant &v)
        {
            const int typeId = v.userType();

            if (QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QPairVariantInterfaceImpl>()) && !(typeId == qMetaTypeId<QPair<QVariant, QVariant> >())) {
                QtMetaTypePrivate::QPairVariantInterfaceImpl pi = v.value<QtMetaTypePrivate::QPairVariantInterfaceImpl>();
                const QtMetaTypePrivate::VariantData d1 = pi.first();
                QVariant v1(d1.metaTypeId, d1.data, d1.flags);
                if (d1.metaTypeId == qMetaTypeId<QVariant>())
                    v1 = *reinterpret_cast<const QVariant*>(d1.data);

                const QtMetaTypePrivate::VariantData d2 = pi.second();
                QVariant v2(d2.metaTypeId, d2.data, d2.flags);
                if (d2.metaTypeId == qMetaTypeId<QVariant>())
                    v2 = *reinterpret_cast<const QVariant*>(d2.data);

                return QPair<QVariant, QVariant>(v1, v2);
            }
            return QVariantValueHelper<QPair<QVariant, QVariant> >::invoke(v);
        }
    };
}

template<typename T> inline T qvariant_cast(const QVariant &v)
{
    return QtPrivate::QVariantValueHelperInterface<T>::invoke(v);
}

template<> inline QVariant qvariant_cast<QVariant>(const QVariant &v)
{
    if (v.userType() == QMetaType::QVariant)
        return *reinterpret_cast<const QVariant *>(v.constData());
    return v;
}









#line 898 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"

#line 900 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"


__declspec(dllimport) QDebug operator<<(QDebug, const QVariant &);
__declspec(dllimport) QDebug operator<<(QDebug, const QVariant::Type);
#line 905 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"



#line 909 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qvariant.h"
#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"






class QCalendar;
class QDataStream;
class QDate;
class QDateTime;
class QLocale;
class QTime;
class QVariant;
class QTextStream;
class QTextStreamPrivate;

class QLocalePrivate;

__declspec(dllimport) uint qHash(const QLocale &key, uint seed = 0) noexcept;

class __declspec(dllimport) QLocale
{
    public: static const QMetaObject staticMetaObject; void qt_check_for_QGADGET_macro(); typedef void QtGadgetHelper; private: __pragma(warning(push))   static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); __pragma(warning(pop)) 
    friend class QString;
    friend class QStringRef;
    friend class QByteArray;
    friend class QIntValidator;
    friend class QDoubleValidatorPrivate;
    friend class QTextStream;
    friend class QTextStreamPrivate;

public:


    enum Language {
        AnyLanguage = 0,
        C = 1,
        Abkhazian = 2,
        Oromo = 3,
        Afar = 4,
        Afrikaans = 5,
        Albanian = 6,
        Amharic = 7,
        Arabic = 8,
        Armenian = 9,
        Assamese = 10,
        Aymara = 11,
        Azerbaijani = 12,
        Bashkir = 13,
        Basque = 14,
        Bengali = 15,
        Dzongkha = 16,


#line 99 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Bislama = 18,
        Breton = 19,
        Bulgarian = 20,
        Burmese = 21,
        Belarusian = 22,
        Khmer = 23,
        Catalan = 24,
        Chinese = 25,
        Corsican = 26,
        Croatian = 27,
        Czech = 28,
        Danish = 29,
        Dutch = 30,
        English = 31,
        Esperanto = 32,
        Estonian = 33,
        Faroese = 34,
        Fijian = 35,
        Finnish = 36,
        French = 37,
        WesternFrisian = 38,
        Gaelic = 39,
        Galician = 40,
        Georgian = 41,
        German = 42,
        Greek = 43,
        Greenlandic = 44,
        Guarani = 45,
        Gujarati = 46,
        Hausa = 47,
        Hebrew = 48,
        Hindi = 49,
        Hungarian = 50,
        Icelandic = 51,
        Indonesian = 52,
        Interlingua = 53,
        Interlingue = 54,
        Inuktitut = 55,
        Inupiak = 56,
        Irish = 57,
        Italian = 58,
        Japanese = 59,
        Javanese = 60,
        Kannada = 61,
        Kashmiri = 62,
        Kazakh = 63,
        Kinyarwanda = 64,
        Kirghiz = 65,
        Korean = 66,
        Kurdish = 67,
        Rundi = 68,
        Lao = 69,
        Latin = 70,
        Latvian = 71,
        Lingala = 72,
        Lithuanian = 73,
        Macedonian = 74,
        Malagasy = 75,
        Malay = 76,
        Malayalam = 77,
        Maltese = 78,
        Maori = 79,
        Marathi = 80,
        Marshallese = 81,
        Mongolian = 82,
        NauruLanguage = 83,
        Nepali = 84,
        NorwegianBokmal = 85,
        Occitan = 86,
        Oriya = 87,
        Pashto = 88,
        Persian = 89,
        Polish = 90,
        Portuguese = 91,
        Punjabi = 92,
        Quechua = 93,
        Romansh = 94,
        Romanian = 95,
        Russian = 96,
        Samoan = 97,
        Sango = 98,
        Sanskrit = 99,
        Serbian = 100,
        Ossetic = 101,
        SouthernSotho = 102,
        Tswana = 103,
        Shona = 104,
        Sindhi = 105,
        Sinhala = 106,
        Swati = 107,
        Slovak = 108,
        Slovenian = 109,
        Somali = 110,
        Spanish = 111,
        Sundanese = 112,
        Swahili = 113,
        Swedish = 114,
        Sardinian = 115,
        Tajik = 116,
        Tamil = 117,
        Tatar = 118,
        Telugu = 119,
        Thai = 120,
        Tibetan = 121,
        Tigrinya = 122,
        Tongan = 123,
        Tsonga = 124,
        Turkish = 125,
        Turkmen = 126,
        Tahitian = 127,
        Uighur = 128,
        Ukrainian = 129,
        Urdu = 130,
        Uzbek = 131,
        Vietnamese = 132,
        Volapuk = 133,
        Welsh = 134,
        Wolof = 135,
        Xhosa = 136,
        Yiddish = 137,
        Yoruba = 138,
        Zhuang = 139,
        Zulu = 140,
        NorwegianNynorsk = 141,
        Bosnian = 142,
        Divehi = 143,
        Manx = 144,
        Cornish = 145,
        Akan = 146,
        Konkani = 147,
        Ga = 148,
        Igbo = 149,
        Kamba = 150,
        Syriac = 151,
        Blin = 152,
        Geez = 153,
        Koro = 154,
        Sidamo = 155,
        Atsam = 156,
        Tigre = 157,
        Jju = 158,
        Friulian = 159,
        Venda = 160,
        Ewe = 161,
        Walamo = 162,
        Hawaiian = 163,
        Tyap = 164,
        Nyanja = 165,
        Filipino = 166,
        SwissGerman = 167,
        SichuanYi = 168,
        Kpelle = 169,
        LowGerman = 170,
        SouthNdebele = 171,
        NorthernSotho = 172,
        NorthernSami = 173,
        Taroko = 174,
        Gusii = 175,
        Taita = 176,
        Fulah = 177,
        Kikuyu = 178,
        Samburu = 179,
        Sena = 180,
        NorthNdebele = 181,
        Rombo = 182,
        Tachelhit = 183,
        Kabyle = 184,
        Nyankole = 185,
        Bena = 186,
        Vunjo = 187,
        Bambara = 188,
        Embu = 189,
        Cherokee = 190,
        Morisyen = 191,
        Makonde = 192,
        Langi = 193,
        Ganda = 194,
        Bemba = 195,
        Kabuverdianu = 196,
        Meru = 197,
        Kalenjin = 198,
        Nama = 199,
        Machame = 200,
        Colognian = 201,
        Masai = 202,
        Soga = 203,
        Luyia = 204,
        Asu = 205,
        Teso = 206,
        Saho = 207,
        KoyraChiini = 208,
        Rwa = 209,
        Luo = 210,
        Chiga = 211,
        CentralMoroccoTamazight = 212,
        KoyraboroSenni = 213,
        Shambala = 214,
        Bodo = 215,
        Avaric = 216,
        Chamorro = 217,
        Chechen = 218,
        Church = 219,
        Chuvash = 220,
        Cree = 221,
        Haitian = 222,
        Herero = 223,
        HiriMotu = 224,
        Kanuri = 225,
        Komi = 226,
        Kongo = 227,
        Kwanyama = 228,
        Limburgish = 229,
        LubaKatanga = 230,
        Luxembourgish = 231,
        Navaho = 232,
        Ndonga = 233,
        Ojibwa = 234,
        Pali = 235,
        Walloon = 236,
        Aghem = 237,
        Basaa = 238,
        Zarma = 239,
        Duala = 240,
        JolaFonyi = 241,
        Ewondo = 242,
        Bafia = 243,
        MakhuwaMeetto = 244,
        Mundang = 245,
        Kwasio = 246,
        Nuer = 247,
        Sakha = 248,
        Sangu = 249,


#line 334 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Tasawaq = 251,
        Vai = 252,
        Walser = 253,
        Yangben = 254,
        Avestan = 255,
        Asturian = 256,
        Ngomba = 257,
        Kako = 258,
        Meta = 259,
        Ngiemboon = 260,
        Aragonese = 261,
        Akkadian = 262,
        AncientEgyptian = 263,
        AncientGreek = 264,
        Aramaic = 265,
        Balinese = 266,
        Bamun = 267,
        BatakToba = 268,
        Buginese = 269,



#line 357 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Chakma = 272,


#line 361 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Coptic = 274,
        Dogri = 275,




#line 368 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Gothic = 279,


#line 372 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Ingush = 281,








#line 382 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Mandingo = 289,
        Manipuri = 290,



#line 388 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        OldIrish = 293,
        OldNorse = 294,
        OldPersian = 295,


#line 394 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Pahlavi = 297,


#line 398 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Phoenician = 299,





#line 405 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Santali = 304,
        Saurashtra = 305,




#line 412 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        TaiDam = 309,


#line 416 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Ugaritic = 311,
        Akoose = 312,
        Lakota = 313,
        StandardMoroccanTamazight = 314,
        Mapuche = 315,
        CentralKurdish = 316,
        LowerSorbian = 317,
        UpperSorbian = 318,
        Kenyang = 319,
        Mohawk = 320,
        Nko = 321,
        Prussian = 322,
        Kiche = 323,
        SouthernSami = 324,
        LuleSami = 325,
        InariSami = 326,
        SkoltSami = 327,
        Warlpiri = 328,


#line 437 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Mende = 330,





#line 444 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Lezghian = 335,




#line 450 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Maithili = 339,


#line 454 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        AmericanSignLanguage = 341,


#line 458 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Bhojpuri = 343,


#line 462 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        LiteraryChinese = 345,
        Mazanderani = 346,


#line 467 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Newari = 348,
        NorthernLuri = 349,
        Palauan = 350,
        Papiamento = 351,


#line 474 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        TokelauLanguage = 353,
        TokPisin = 354,
        TuvaluLanguage = 355,


#line 480 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Cantonese = 357,
        Osage = 358,


#line 485 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Ido = 360,
        Lojban = 361,
        Sicilian = 362,
        SouthernKurdish = 363,
        WesternBalochi = 364,
        Cebuano = 365,
        Erzya = 366,
        Chickasaw = 367,
        Muscogee = 368,
        Silesian = 369,
        NigerianPidgin = 370,

        Afan = Oromo,
        Bhutani = Dzongkha,
        Byelorussian = Belarusian,
        Cambodian = Khmer,
        Chewa = Nyanja,
        Frisian = WesternFrisian,
        Kurundi = Rundi,



#line 508 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        RhaetoRomance = Romansh,




#line 514 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
        Uigur = Uighur,

        LastLanguage = NigerianPidgin
    };

    enum Script {
        AnyScript = 0,
        ArabicScript = 1,
        CyrillicScript = 2,
        DeseretScript = 3,
        GurmukhiScript = 4,
        SimplifiedHanScript = 5,
        TraditionalHanScript = 6,
        LatinScript = 7,
        MongolianScript = 8,
        TifinaghScript = 9,
        ArmenianScript = 10,
        BengaliScript = 11,
        CherokeeScript = 12,
        DevanagariScript = 13,
        EthiopicScript = 14,
        GeorgianScript = 15,
        GreekScript = 16,
        GujaratiScript = 17,
        HebrewScript = 18,
        JapaneseScript = 19,
        KhmerScript = 20,
        KannadaScript = 21,
        KoreanScript = 22,
        LaoScript = 23,
        MalayalamScript = 24,
        MyanmarScript = 25,
        OriyaScript = 26,
        TamilScript = 27,
        TeluguScript = 28,
        ThaanaScript = 29,
        ThaiScript = 30,
        TibetanScript = 31,
        SinhalaScript = 32,
        SyriacScript = 33,
        YiScript = 34,
        VaiScript = 35,
        AvestanScript = 36,
        BalineseScript = 37,
        BamumScript = 38,
        BatakScript = 39,
        BopomofoScript = 40,
        BrahmiScript = 41,
        BugineseScript = 42,
        BuhidScript = 43,
        CanadianAboriginalScript = 44,
        CarianScript = 45,
        ChakmaScript = 46,
        ChamScript = 47,
        CopticScript = 48,
        CypriotScript = 49,
        EgyptianHieroglyphsScript = 50,
        FraserScript = 51,
        GlagoliticScript = 52,
        GothicScript = 53,
        HanScript = 54,
        HangulScript = 55,
        HanunooScript = 56,
        ImperialAramaicScript = 57,
        InscriptionalPahlaviScript = 58,
        InscriptionalParthianScript = 59,
        JavaneseScript = 60,
        KaithiScript = 61,
        KatakanaScript = 62,
        KayahLiScript = 63,
        KharoshthiScript = 64,
        LannaScript = 65,
        LepchaScript = 66,
        LimbuScript = 67,
        LinearBScript = 68,
        LycianScript = 69,
        LydianScript = 70,
        MandaeanScript = 71,
        MeiteiMayekScript = 72,
        MeroiticScript = 73,
        MeroiticCursiveScript = 74,
        NkoScript = 75,
        NewTaiLueScript = 76,
        OghamScript = 77,
        OlChikiScript = 78,
        OldItalicScript = 79,
        OldPersianScript = 80,
        OldSouthArabianScript = 81,
        OrkhonScript = 82,
        OsmanyaScript = 83,
        PhagsPaScript = 84,
        PhoenicianScript = 85,
        PollardPhoneticScript = 86,
        RejangScript = 87,
        RunicScript = 88,
        SamaritanScript = 89,
        SaurashtraScript = 90,
        SharadaScript = 91,
        ShavianScript = 92,
        SoraSompengScript = 93,
        CuneiformScript = 94,
        SundaneseScript = 95,
        SylotiNagriScript = 96,
        TagalogScript = 97,
        TagbanwaScript = 98,
        TaiLeScript = 99,
        TaiVietScript = 100,
        TakriScript = 101,
        UgariticScript = 102,
        BrailleScript = 103,
        HiraganaScript = 104,
        CaucasianAlbanianScript = 105,
        BassaVahScript = 106,
        DuployanScript = 107,
        ElbasanScript = 108,
        GranthaScript = 109,
        PahawhHmongScript = 110,
        KhojkiScript = 111,
        LinearAScript = 112,
        MahajaniScript = 113,
        ManichaeanScript = 114,
        MendeKikakuiScript = 115,
        ModiScript = 116,
        MroScript = 117,
        OldNorthArabianScript = 118,
        NabataeanScript = 119,
        PalmyreneScript = 120,
        PauCinHauScript = 121,
        OldPermicScript = 122,
        PsalterPahlaviScript = 123,
        SiddhamScript = 124,
        KhudawadiScript = 125,
        TirhutaScript = 126,
        VarangKshitiScript = 127,
        AhomScript = 128,
        AnatolianHieroglyphsScript = 129,
        HatranScript = 130,
        MultaniScript = 131,
        OldHungarianScript = 132,
        SignWritingScript = 133,
        AdlamScript = 134,
        BhaiksukiScript = 135,
        MarchenScript = 136,
        NewaScript = 137,
        OsageScript = 138,
        TangutScript = 139,
        HanWithBopomofoScript = 140,
        JamoScript = 141,

        SimplifiedChineseScript = SimplifiedHanScript,
        TraditionalChineseScript = TraditionalHanScript,

        LastScript = JamoScript
    };

    enum Country {
        AnyCountry = 0,
        Afghanistan = 1,
        Albania = 2,
        Algeria = 3,
        AmericanSamoa = 4,
        Andorra = 5,
        Angola = 6,
        Anguilla = 7,
        Antarctica = 8,
        AntiguaAndBarbuda = 9,
        Argentina = 10,
        Armenia = 11,
        Aruba = 12,
        Australia = 13,
        Austria = 14,
        Azerbaijan = 15,
        Bahamas = 16,
        Bahrain = 17,
        Bangladesh = 18,
        Barbados = 19,
        Belarus = 20,
        Belgium = 21,
        Belize = 22,
        Benin = 23,
        Bermuda = 24,
        Bhutan = 25,
        Bolivia = 26,
        BosniaAndHerzegowina = 27,
        Botswana = 28,
        BouvetIsland = 29,
        Brazil = 30,
        BritishIndianOceanTerritory = 31,
        Brunei = 32,
        Bulgaria = 33,
        BurkinaFaso = 34,
        Burundi = 35,
        Cambodia = 36,
        Cameroon = 37,
        Canada = 38,
        CapeVerde = 39,
        CaymanIslands = 40,
        CentralAfricanRepublic = 41,
        Chad = 42,
        Chile = 43,
        China = 44,
        ChristmasIsland = 45,
        CocosIslands = 46,
        Colombia = 47,
        Comoros = 48,
        CongoKinshasa = 49,
        CongoBrazzaville = 50,
        CookIslands = 51,
        CostaRica = 52,
        IvoryCoast = 53,
        Croatia = 54,
        Cuba = 55,
        Cyprus = 56,
        CzechRepublic = 57,
        Denmark = 58,
        Djibouti = 59,
        Dominica = 60,
        DominicanRepublic = 61,
        EastTimor = 62,
        Ecuador = 63,
        Egypt = 64,
        ElSalvador = 65,
        EquatorialGuinea = 66,
        Eritrea = 67,
        Estonia = 68,
        Ethiopia = 69,
        FalklandIslands = 70,
        FaroeIslands = 71,
        Fiji = 72,
        Finland = 73,
        France = 74,
        Guernsey = 75,
        FrenchGuiana = 76,
        FrenchPolynesia = 77,
        FrenchSouthernTerritories = 78,
        Gabon = 79,
        Gambia = 80,
        Georgia = 81,
        Germany = 82,
        Ghana = 83,
        Gibraltar = 84,
        Greece = 85,
        Greenland = 86,
        Grenada = 87,
        Guadeloupe = 88,
        Guam = 89,
        Guatemala = 90,
        Guinea = 91,
        GuineaBissau = 92,
        Guyana = 93,
        Haiti = 94,
        HeardAndMcDonaldIslands = 95,
        Honduras = 96,
        HongKong = 97,
        Hungary = 98,
        Iceland = 99,
        India = 100,
        Indonesia = 101,
        Iran = 102,
        Iraq = 103,
        Ireland = 104,
        Israel = 105,
        Italy = 106,
        Jamaica = 107,
        Japan = 108,
        Jordan = 109,
        Kazakhstan = 110,
        Kenya = 111,
        Kiribati = 112,
        NorthKorea = 113,
        SouthKorea = 114,
        Kuwait = 115,
        Kyrgyzstan = 116,
        Laos = 117,
        Latvia = 118,
        Lebanon = 119,
        Lesotho = 120,
        Liberia = 121,
        Libya = 122,
        Liechtenstein = 123,
        Lithuania = 124,
        Luxembourg = 125,
        Macau = 126,
        Macedonia = 127,
        Madagascar = 128,
        Malawi = 129,
        Malaysia = 130,
        Maldives = 131,
        Mali = 132,
        Malta = 133,
        MarshallIslands = 134,
        Martinique = 135,
        Mauritania = 136,
        Mauritius = 137,
        Mayotte = 138,
        Mexico = 139,
        Micronesia = 140,
        Moldova = 141,
        Monaco = 142,
        Mongolia = 143,
        Montserrat = 144,
        Morocco = 145,
        Mozambique = 146,
        Myanmar = 147,
        Namibia = 148,
        NauruCountry = 149,
        Nepal = 150,
        Netherlands = 151,
        CuraSao = 152,
        NewCaledonia = 153,
        NewZealand = 154,
        Nicaragua = 155,
        Niger = 156,
        Nigeria = 157,
        Niue = 158,
        NorfolkIsland = 159,
        NorthernMarianaIslands = 160,
        Norway = 161,
        Oman = 162,
        Pakistan = 163,
        Palau = 164,
        PalestinianTerritories = 165,
        Panama = 166,
        PapuaNewGuinea = 167,
        Paraguay = 168,
        Peru = 169,
        Philippines = 170,
        Pitcairn = 171,
        Poland = 172,
        Portugal = 173,
        PuertoRico = 174,
        Qatar = 175,
        Reunion = 176,
        Romania = 177,
        Russia = 178,
        Rwanda = 179,
        SaintKittsAndNevis = 180,
        SaintLucia = 181,
        SaintVincentAndTheGrenadines = 182,
        Samoa = 183,
        SanMarino = 184,
        SaoTomeAndPrincipe = 185,
        SaudiArabia = 186,
        Senegal = 187,
        Seychelles = 188,
        SierraLeone = 189,
        Singapore = 190,
        Slovakia = 191,
        Slovenia = 192,
        SolomonIslands = 193,
        Somalia = 194,
        SouthAfrica = 195,
        SouthGeorgiaAndTheSouthSandwichIslands = 196,
        Spain = 197,
        SriLanka = 198,
        SaintHelena = 199,
        SaintPierreAndMiquelon = 200,
        Sudan = 201,
        Suriname = 202,
        SvalbardAndJanMayenIslands = 203,
        Swaziland = 204,
        Sweden = 205,
        Switzerland = 206,
        Syria = 207,
        Taiwan = 208,
        Tajikistan = 209,
        Tanzania = 210,
        Thailand = 211,
        Togo = 212,
        TokelauCountry = 213,
        Tonga = 214,
        TrinidadAndTobago = 215,
        Tunisia = 216,
        Turkey = 217,
        Turkmenistan = 218,
        TurksAndCaicosIslands = 219,
        TuvaluCountry = 220,
        Uganda = 221,
        Ukraine = 222,
        UnitedArabEmirates = 223,
        UnitedKingdom = 224,
        UnitedStates = 225,
        UnitedStatesMinorOutlyingIslands = 226,
        Uruguay = 227,
        Uzbekistan = 228,
        Vanuatu = 229,
        VaticanCityState = 230,
        Venezuela = 231,
        Vietnam = 232,
        BritishVirginIslands = 233,
        UnitedStatesVirginIslands = 234,
        WallisAndFutunaIslands = 235,
        WesternSahara = 236,
        Yemen = 237,
        CanaryIslands = 238,
        Zambia = 239,
        Zimbabwe = 240,
        ClippertonIsland = 241,
        Montenegro = 242,
        Serbia = 243,
        SaintBarthelemy = 244,
        SaintMartin = 245,
        LatinAmerica = 246,
        AscensionIsland = 247,
        AlandIslands = 248,
        DiegoGarcia = 249,
        CeutaAndMelilla = 250,
        IsleOfMan = 251,
        Jersey = 252,
        TristanDaCunha = 253,
        SouthSudan = 254,
        Bonaire = 255,
        SintMaarten = 256,
        Kosovo = 257,
        EuropeanUnion = 258,
        OutlyingOceania = 259,
        World = 260,
        Europe = 261,

        DemocraticRepublicOfCongo = CongoKinshasa,
        DemocraticRepublicOfKorea = NorthKorea,
        LatinAmericaAndTheCaribbean = LatinAmerica,
        PeoplesRepublicOfCongo = CongoBrazzaville,
        RepublicOfKorea = SouthKorea,
        RussianFederation = Russia,
        SyrianArabRepublic = Syria,



#line 944 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"

        LastCountry = Europe
    };


     friend constexpr const QMetaObject *qt_getEnumMetaObject(Language) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(Language) noexcept { return "Language"; }
     friend constexpr const QMetaObject *qt_getEnumMetaObject(Country) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(Country) noexcept { return "Country"; }
     friend constexpr const QMetaObject *qt_getEnumMetaObject(Script) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(Script) noexcept { return "Script"; }

    enum MeasurementSystem {
        MetricSystem,
        ImperialUSSystem,
        ImperialUKSystem,
        ImperialSystem = ImperialUSSystem 
    };
     friend constexpr const QMetaObject *qt_getEnumMetaObject(MeasurementSystem) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(MeasurementSystem) noexcept { return "MeasurementSystem"; }

    enum FormatType { LongFormat, ShortFormat, NarrowFormat };
    enum NumberOption {
        DefaultNumberOptions = 0x0,
        OmitGroupSeparator = 0x01,
        RejectGroupSeparator = 0x02,
        OmitLeadingZeroInExponent = 0x04,
        RejectLeadingZeroInExponent = 0x08,
        IncludeTrailingZeroesAfterDot = 0x10,
        RejectTrailingZeroesAfterDot = 0x20
    };
    typedef QFlags<NumberOption> NumberOptions;

    enum FloatingPointPrecisionOption {
        FloatingPointShortest = -128
    };

    enum CurrencySymbolFormat {
        CurrencyIsoCode,
        CurrencySymbol,
        CurrencyDisplayName
    };

    enum DataSizeFormat {
        
        DataSizeBase1000 = 1, 
        DataSizeSIQuantifiers = 2, 

        
        DataSizeIecFormat = 0, 
        DataSizeTraditionalFormat = DataSizeSIQuantifiers, 
        DataSizeSIFormat = DataSizeBase1000 | DataSizeSIQuantifiers 
    };
    typedef QFlags<DataSizeFormat> DataSizeFormats;
     friend constexpr const QMetaObject *qt_getEnumMetaObject(DataSizeFormats) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(DataSizeFormats) noexcept { return "DataSizeFormats"; }

    QLocale();
    QLocale(const QString &name);
    QLocale(Language language, Country country = AnyCountry);
    QLocale(Language language, Script script, Country country);
    QLocale(const QLocale &other);
    QLocale &operator=(QLocale &&other) noexcept { swap(other); return *this; }
    QLocale &operator=(const QLocale &other);
    ~QLocale();

    void swap(QLocale &other) noexcept { qSwap(d, other.d); }

    Language language() const;
    Script script() const;
    Country country() const;
    QString name() const;

    QString bcp47Name() const;
    QString nativeLanguageName() const;
    QString nativeCountryName() const;


    short toShort(const QString &s, bool *ok = nullptr) const;
    ushort toUShort(const QString &s, bool *ok = nullptr) const;
    int toInt(const QString &s, bool *ok = nullptr) const;
    uint toUInt(const QString &s, bool *ok = nullptr) const;
    long toLong(const QString &s, bool *ok = nullptr) const;
    ulong toULong(const QString &s, bool *ok = nullptr) const;
    qlonglong toLongLong(const QString &s, bool *ok = nullptr) const;
    qulonglong toULongLong(const QString &s, bool *ok = nullptr) const;
    float toFloat(const QString &s, bool *ok = nullptr) const;
    double toDouble(const QString &s, bool *ok = nullptr) const;

    short toShort(const QStringRef &s, bool *ok = nullptr) const;
    ushort toUShort(const QStringRef &s, bool *ok = nullptr) const;
    int toInt(const QStringRef &s, bool *ok = nullptr) const;
    uint toUInt(const QStringRef &s, bool *ok = nullptr) const;
    long toLong(const QStringRef &s, bool *ok = nullptr) const;
    ulong toULong(const QStringRef &s, bool *ok = nullptr) const;
    qlonglong toLongLong(const QStringRef &s, bool *ok = nullptr) const;
    qulonglong toULongLong(const QStringRef &s, bool *ok = nullptr) const;
    float toFloat(const QStringRef &s, bool *ok = nullptr) const;
    double toDouble(const QStringRef &s, bool *ok = nullptr) const;
#line 1039 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"

    short toShort(QStringView s, bool *ok = nullptr) const;
    ushort toUShort(QStringView s, bool *ok = nullptr) const;
    int toInt(QStringView s, bool *ok = nullptr) const;
    uint toUInt(QStringView s, bool *ok = nullptr) const;
    long toLong(QStringView s, bool *ok = nullptr) const;
    ulong toULong(QStringView s, bool *ok = nullptr) const;
    qlonglong toLongLong(QStringView s, bool *ok = nullptr) const;
    qulonglong toULongLong(QStringView s, bool *ok = nullptr) const;
    float toFloat(QStringView s, bool *ok = nullptr) const;
    double toDouble(QStringView s, bool *ok = nullptr) const;

    QString toString(qlonglong i) const;
    QString toString(qulonglong i) const;
    inline QString toString(long i) const;
    inline QString toString(ulong i) const;
    inline QString toString(short i) const;
    inline QString toString(ushort i) const;
    inline QString toString(int i) const;
    inline QString toString(uint i) const;
    QString toString(double i, char f = 'g', int prec = 6) const;
    inline QString toString(float i, char f = 'g', int prec = 6) const;


    QString toString(const QDate &date, const QString &formatStr) const;
    QString toString(const QTime &time, const QString &formatStr) const;
    QString toString(const QDateTime &dateTime, const QString &format) const;
#line 1067 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
    QString toString(const QDate &date, QStringView formatStr) const;
    QString toString(const QTime &time, QStringView formatStr) const;
    QString toString(const QDateTime &dateTime, QStringView format) const;
    QString toString(const QDate &date, FormatType format = LongFormat) const;
    QString toString(const QTime &time, FormatType format = LongFormat) const;
    QString toString(const QDateTime &dateTime, FormatType format = LongFormat) const;
    




    QString toString(const QDate &date, QStringView formatStr, QCalendar cal) const;
    QString toString(const QDate &date, FormatType format, QCalendar cal) const;
    QString toString(const QDateTime &dateTime, FormatType format, QCalendar cal) const;
    QString toString(const QDateTime &dateTime, QStringView formatStr, QCalendar cal) const;

    QString dateFormat(FormatType format = LongFormat) const;
    QString timeFormat(FormatType format = LongFormat) const;
    QString dateTimeFormat(FormatType format = LongFormat) const;

    QDate toDate(const QString &string, FormatType = LongFormat) const;
    QTime toTime(const QString &string, FormatType = LongFormat) const;
    QDateTime toDateTime(const QString &string, FormatType format = LongFormat) const;
    QDate toDate(const QString &string, const QString &format) const;
    QTime toTime(const QString &string, const QString &format) const;
    QDateTime toDateTime(const QString &string, const QString &format) const;
    
    QDate toDate(const QString &string, FormatType format, QCalendar cal) const;
    QDateTime toDateTime(const QString &string, FormatType format, QCalendar cal) const;
    QDate toDate(const QString &string, const QString &format, QCalendar cal) const;
    QDateTime toDateTime(const QString &string, const QString &format, QCalendar cal) const;





#line 1104 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
#line 1105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"

    
    
    QChar decimalPoint() const;
    QChar groupSeparator() const;
    QChar percent() const;
    QChar zeroDigit() const;
    QChar negativeSign() const;
    QChar positiveSign() const;
    QChar exponential() const;

    QString monthName(int, FormatType format = LongFormat) const;
    QString standaloneMonthName(int, FormatType format = LongFormat) const;
    QString dayName(int, FormatType format = LongFormat) const;
    QString standaloneDayName(int, FormatType format = LongFormat) const;

    Qt::DayOfWeek firstDayOfWeek() const;
    QList<Qt::DayOfWeek> weekdays() const;

    QString amText() const;
    QString pmText() const;

    MeasurementSystem measurementSystem() const;
    QLocale collation() const;
    Qt::LayoutDirection textDirection() const;

    QString toUpper(const QString &str) const;
    QString toLower(const QString &str) const;

    QString currencySymbol(CurrencySymbolFormat = CurrencySymbol) const;
    QString toCurrencyString(qlonglong, const QString &symbol = QString()) const;
    QString toCurrencyString(qulonglong, const QString &symbol = QString()) const;
    inline QString toCurrencyString(short, const QString &symbol = QString()) const;
    inline QString toCurrencyString(ushort, const QString &symbol = QString()) const;
    inline QString toCurrencyString(int, const QString &symbol = QString()) const;
    inline QString toCurrencyString(uint, const QString &symbol = QString()) const;




#line 1146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
    QString toCurrencyString(double, const QString &symbol = QString()) const;
    QString toCurrencyString(double, const QString &symbol, int precision) const;
    inline QString toCurrencyString(float i, const QString &symbol = QString()) const
    { return toCurrencyString(double(i), symbol); }
    inline QString toCurrencyString(float i, const QString &symbol, int precision) const
    { return toCurrencyString(double(i), symbol, precision); }
#line 1153 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"


    QString formattedDataSize(qint64 bytes, int precision = 2, DataSizeFormats format = DataSizeIecFormat);
#line 1157 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
    QString formattedDataSize(qint64 bytes, int precision = 2, DataSizeFormats format = DataSizeIecFormat) const;

    QStringList uiLanguages() const;

    bool operator==(const QLocale &other) const;
    bool operator!=(const QLocale &other) const;

    static QString languageToString(Language language);
    static QString countryToString(Country country);
    static QString scriptToString(Script script);
    static void setDefault(const QLocale &locale);

    static QLocale c() { return QLocale(C); }
    static QLocale system();

    static QList<QLocale> matchingLocales(QLocale::Language language, QLocale::Script script, QLocale::Country country);
    static QList<Country> countriesForLanguage(Language lang);

    void setNumberOptions(NumberOptions options);
    NumberOptions numberOptions() const;

    enum QuotationStyle { StandardQuotation, AlternateQuotation };
    QString quoteString(const QString &str, QuotationStyle style = StandardQuotation) const;
    QString quoteString(const QStringRef &str, QuotationStyle style = StandardQuotation) const;

    QString createSeparatedList(const QStringList &strl) const;

private:
    QLocale(QLocalePrivate &dd);
    friend class QLocalePrivate;
    friend class QSystemLocale;
    friend class QCalendarBackend;
    friend class QGregorianCalendar;
    friend __declspec(dllimport) uint qHash(const QLocale &key, uint seed) noexcept;

    QSharedDataPointer<QLocalePrivate> d;
};
template<> class QTypeInfo<QLocale > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QLocale>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QLocale>(), isLarge = (sizeof(QLocale)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QLocale >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QLocale) }; static inline const char *name() { return "QLocale"; } }; inline void swap(QLocale &value1, QLocale &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
constexpr inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QLocale::NumberOptions::enum_type f2) noexcept { return QFlags<QLocale::NumberOptions::enum_type>(f1) | f2; } constexpr inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QFlags<QLocale::NumberOptions::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QLocale::NumberOptions::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }

inline QString QLocale::toString(long i) const
    { return toString(qlonglong(i)); }
inline QString QLocale::toString(ulong i) const
    { return toString(qulonglong(i)); }
inline QString QLocale::toString(short i) const
    { return toString(qlonglong(i)); }
inline QString QLocale::toString(ushort i) const
    { return toString(qulonglong(i)); }
inline QString QLocale::toString(int i) const
    { return toString(qlonglong(i)); }
inline QString QLocale::toString(uint i) const
    { return toString(qulonglong(i)); }
inline QString QLocale::toString(float i, char f, int prec) const
    { return toString(double(i), f, prec); }

inline QString QLocale::toCurrencyString(short i, const QString &symbol) const
    { return toCurrencyString(qlonglong(i), symbol); }
inline QString QLocale::toCurrencyString(ushort i, const QString &symbol) const
    { return toCurrencyString(qulonglong(i), symbol); }
inline QString QLocale::toCurrencyString(int i, const QString &symbol) const
{ return toCurrencyString(qlonglong(i), symbol); }
inline QString QLocale::toCurrencyString(uint i, const QString &symbol) const
{ return toCurrencyString(qulonglong(i), symbol); }


__declspec(dllimport) QDataStream &operator<<(QDataStream &, const QLocale &);
__declspec(dllimport) QDataStream &operator>>(QDataStream &, QLocale &);
#line 1225 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"


__declspec(dllimport) QDebug operator<<(QDebug, const QLocale &);
#line 1229 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"



#line 1233 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qlocale.h"
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtextstream.h"











class QTextCodec;
class QTextDecoder;

class QTextStreamPrivate;
class __declspec(dllimport) QTextStream                                
{
    inline QTextStreamPrivate* d_func() { __pragma(warning(push))  return reinterpret_cast<QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); __pragma(warning(pop)) } inline const QTextStreamPrivate* d_func() const { __pragma(warning(push))  return reinterpret_cast<const QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); __pragma(warning(pop)) } friend class QTextStreamPrivate;

public:
    enum RealNumberNotation {
        SmartNotation,
        FixedNotation,
        ScientificNotation
    };
    enum FieldAlignment {
        AlignLeft,
        AlignRight,
        AlignCenter,
        AlignAccountingStyle
    };
    enum Status {
        Ok,
        ReadPastEnd,
        ReadCorruptData,
        WriteFailed
    };
    enum NumberFlag {
        ShowBase = 0x1,
        ForcePoint = 0x2,
        ForceSign = 0x4,
        UppercaseBase = 0x8,
        UppercaseDigits = 0x10
    };
    typedef QFlags<NumberFlag> NumberFlags;

    QTextStream();
    explicit QTextStream(QIODevice *device);
    explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
    virtual ~QTextStream();


    void setCodec(QTextCodec *codec);
    void setCodec(const char *codecName);
    QTextCodec *codec() const;
    void setAutoDetectUnicode(bool enabled);
    bool autoDetectUnicode() const;
    void setGenerateByteOrderMark(bool generate);
    bool generateByteOrderMark() const;
#line 110 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtextstream.h"

    void setLocale(const QLocale &locale);
    QLocale locale() const;

    void setDevice(QIODevice *device);
    QIODevice *device() const;

    void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
    QString *string() const;

    Status status() const;
    void setStatus(Status status);
    void resetStatus();

    bool atEnd() const;
    void reset();
    void flush();
    bool seek(qint64 pos);
    qint64 pos() const;

    void skipWhiteSpace();

    QString readLine(qint64 maxlen = 0);
    bool readLineInto(QString *line, qint64 maxlen = 0);
    QString readAll();
    QString read(qint64 maxlen);

    void setFieldAlignment(FieldAlignment alignment);
    FieldAlignment fieldAlignment() const;

    void setPadChar(QChar ch);
    QChar padChar() const;

    void setFieldWidth(int width);
    int fieldWidth() const;

    void setNumberFlags(NumberFlags flags);
    NumberFlags numberFlags() const;

    void setIntegerBase(int base);
    int integerBase() const;

    void setRealNumberNotation(RealNumberNotation notation);
    RealNumberNotation realNumberNotation() const;

    void setRealNumberPrecision(int precision);
    int realNumberPrecision() const;

    QTextStream &operator>>(QChar &ch);
    QTextStream &operator>>(char &ch);
    QTextStream &operator>>(signed short &i);
    QTextStream &operator>>(unsigned short &i);
    QTextStream &operator>>(signed int &i);
    QTextStream &operator>>(unsigned int &i);
    QTextStream &operator>>(signed long &i);
    QTextStream &operator>>(unsigned long &i);
    QTextStream &operator>>(qlonglong &i);
    QTextStream &operator>>(qulonglong &i);
    QTextStream &operator>>(float &f);
    QTextStream &operator>>(double &f);
    QTextStream &operator>>(QString &s);
    QTextStream &operator>>(QByteArray &array);
    QTextStream &operator>>(char *c);

    QTextStream &operator<<(QChar ch);
    QTextStream &operator<<(char ch);
    QTextStream &operator<<(signed short i);
    QTextStream &operator<<(unsigned short i);
    QTextStream &operator<<(signed int i);
    QTextStream &operator<<(unsigned int i);
    QTextStream &operator<<(signed long i);
    QTextStream &operator<<(unsigned long i);
    QTextStream &operator<<(qlonglong i);
    QTextStream &operator<<(qulonglong i);
    QTextStream &operator<<(float f);
    QTextStream &operator<<(double f);
    QTextStream &operator<<(const QString &s);
    QTextStream &operator<<(QStringView s);
    QTextStream &operator<<(QLatin1String s);
    QTextStream &operator<<(const QStringRef &s);
    QTextStream &operator<<(const QByteArray &array);
    QTextStream &operator<<(const char *c);
    QTextStream &operator<<(const void *ptr);

private:
    QTextStream(const QTextStream &) = delete; QTextStream &operator=(const QTextStream &) = delete;
    friend class QDebugStateSaverPrivate;
    friend class QDebug;

    QScopedPointer<QTextStreamPrivate> d_ptr;
};

constexpr inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QTextStream::NumberFlags::enum_type f2) noexcept { return QFlags<QTextStream::NumberFlags::enum_type>(f1) | f2; } constexpr inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QFlags<QTextStream::NumberFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QTextStream::NumberFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }





typedef QTextStream & (*QTextStreamFunction)(QTextStream &);
typedef void (QTextStream::*QTSMFI)(int); 
typedef void (QTextStream::*QTSMFC)(QChar); 


class __declspec(dllimport) QTextStreamManipulator
{
public:
    constexpr QTextStreamManipulator(QTSMFI m, int a) noexcept : mf(m), mc(nullptr), arg(a), ch() {}
    constexpr QTextStreamManipulator(QTSMFC m, QChar c) noexcept : mf(nullptr), mc(m), arg(-1), ch(c) {}
    void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }

private:
    QTSMFI mf;                                        
    QTSMFC mc;                                        
    int arg;                                          
    QChar ch;
};

inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)
{ return (*f)(s); }

inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)
{ return (*f)(s); }

inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)
{ m.exec(s); return s; }

namespace Qt {
__declspec(dllimport) QTextStream &bin(QTextStream &s);
__declspec(dllimport) QTextStream &oct(QTextStream &s);
__declspec(dllimport) QTextStream &dec(QTextStream &s);
__declspec(dllimport) QTextStream &hex(QTextStream &s);

__declspec(dllimport) QTextStream &showbase(QTextStream &s);
__declspec(dllimport) QTextStream &forcesign(QTextStream &s);
__declspec(dllimport) QTextStream &forcepoint(QTextStream &s);
__declspec(dllimport) QTextStream &noshowbase(QTextStream &s);
__declspec(dllimport) QTextStream &noforcesign(QTextStream &s);
__declspec(dllimport) QTextStream &noforcepoint(QTextStream &s);

__declspec(dllimport) QTextStream &uppercasebase(QTextStream &s);
__declspec(dllimport) QTextStream &uppercasedigits(QTextStream &s);
__declspec(dllimport) QTextStream &lowercasebase(QTextStream &s);
__declspec(dllimport) QTextStream &lowercasedigits(QTextStream &s);

__declspec(dllimport) QTextStream &fixed(QTextStream &s);
__declspec(dllimport) QTextStream &scientific(QTextStream &s);

__declspec(dllimport) QTextStream &left(QTextStream &s);
__declspec(dllimport) QTextStream &right(QTextStream &s);
__declspec(dllimport) QTextStream &center(QTextStream &s);

__declspec(dllimport) QTextStream &endl(QTextStream &s);
__declspec(dllimport) QTextStream &flush(QTextStream &s);
__declspec(dllimport) QTextStream &reset(QTextStream &s);

__declspec(dllimport) QTextStream &bom(QTextStream &s);

__declspec(dllimport) QTextStream &ws(QTextStream &s);

} 




































#line 307 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtextstream.h"

inline QTextStreamManipulator qSetFieldWidth(int width)
{
    QTSMFI func = &QTextStream::setFieldWidth;
    return QTextStreamManipulator(func,width);
}

inline QTextStreamManipulator qSetPadChar(QChar ch)
{
    QTSMFC func = &QTextStream::setPadChar;
    return QTextStreamManipulator(func, ch);
}

inline QTextStreamManipulator qSetRealNumberPrecision(int precision)
{
    QTSMFI func = &QTextStream::setRealNumberPrecision;
    return QTextStreamManipulator(func, precision);
}



#line 329 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qtextstream.h"
#pragma external_header(pop)
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"











































#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontainertools_impl.h"
























































































#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"







template <class T>
class QSet
{
    typedef QHash<T, QHashDummyValue> Hash;

public:
    inline QSet() noexcept {}
    inline QSet(std::initializer_list<T> list)
        : QSet(list.begin(), list.end()) {}
    template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
    inline QSet(InputIterator first, InputIterator last)
    {
        QtPrivate::reserveIfForwardIterator(this, first, last);
        for (; first != last; ++first)
            insert(*first);
    }

    
    

    inline void swap(QSet<T> &other) noexcept { q_hash.swap(other.q_hash); }

    inline bool operator==(const QSet<T> &other) const
        { return q_hash == other.q_hash; }
    inline bool operator!=(const QSet<T> &other) const
        { return q_hash != other.q_hash; }

    inline int size() const { return q_hash.size(); }

    inline bool isEmpty() const { return q_hash.isEmpty(); }

    inline int capacity() const { return q_hash.capacity(); }
    inline void reserve(int size);
    inline void squeeze() { q_hash.squeeze(); }

    inline void detach() { q_hash.detach(); }
    inline bool isDetached() const { return q_hash.isDetached(); }

    inline void setSharable(bool sharable) { q_hash.setSharable(sharable); }
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"

    inline void clear() { q_hash.clear(); }

    inline bool remove(const T &value) { return q_hash.remove(value) != 0; }

    inline bool contains(const T &value) const { return q_hash.contains(value); }

    bool contains(const QSet<T> &set) const;

    class const_iterator;

    class iterator
    {
        typedef QHash<T, QHashDummyValue> Hash;
        typename Hash::iterator i;
        friend class const_iterator;
        friend class QSet<T>;

    public:


#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
        typedef std::forward_iterator_tag iterator_category;
#line 116 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline iterator() {}
        inline iterator(typename Hash::iterator o) : i(o) {}
        inline iterator(const iterator &o) : i(o.i) {}
        inline iterator &operator=(const iterator &o) { i = o.i; return *this; }
        inline const T &operator*() const { return i.key(); }
        inline const T *operator->() const { return &i.key(); }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }
        inline bool operator==(const const_iterator &o) const
            { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != o.i; }
        inline iterator &operator++() { ++i; return *this; }
        inline iterator operator++(int) { iterator r = *this; ++i; return r; }








#line 144 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
    };

    class const_iterator
    {
        typedef QHash<T, QHashDummyValue> Hash;
        typename Hash::const_iterator i;
        friend class iterator;
        friend class QSet<T>;

    public:


#line 157 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
        typedef std::forward_iterator_tag iterator_category;
#line 159 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline const_iterator() {}
        inline const_iterator(typename Hash::const_iterator o) : i(o) {}
        inline const_iterator(const const_iterator &o) : i(o.i) {}
        inline const_iterator(const iterator &o)
            : i(o.i) {}
        inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
        inline const T &operator*() const { return i.key(); }
        inline const T *operator->() const { return &i.key(); }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
        inline const_iterator &operator++() { ++i; return *this; }
        inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; }








#line 185 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
    };

    
    inline iterator begin() { return q_hash.begin(); }
    inline const_iterator begin() const noexcept { return q_hash.begin(); }
    inline const_iterator cbegin() const noexcept { return q_hash.begin(); }
    inline const_iterator constBegin() const noexcept { return q_hash.constBegin(); }
    inline iterator end() { return q_hash.end(); }
    inline const_iterator end() const noexcept { return q_hash.end(); }
    inline const_iterator cend() const noexcept { return q_hash.end(); }
    inline const_iterator constEnd() const noexcept { return q_hash.constEnd(); }











#line 208 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"

    iterator erase(iterator i)
    { return erase(m2c(i)); }
    iterator erase(const_iterator i)
    {
        ((isValidIterator(i)) ? static_cast<void>(0) : qt_assert_x("QSet::erase", "The specified const_iterator argument 'i' is invalid", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h", 213));
        return q_hash.erase(reinterpret_cast<typename Hash::const_iterator &>(i));
    }

    
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return q_hash.count(); }
    inline iterator insert(const T &value)
        { return static_cast<typename Hash::iterator>(q_hash.insert(value, QHashDummyValue())); }
    iterator find(const T &value) { return q_hash.find(value); }
    const_iterator find(const T &value) const { return q_hash.find(value); }
    inline const_iterator constFind(const T &value) const { return find(value); }
    QSet<T> &unite(const QSet<T> &other);
    QSet<T> &intersect(const QSet<T> &other);
    bool intersects(const QSet<T> &other) const;
    QSet<T> &subtract(const QSet<T> &other);

    
    typedef T key_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef qptrdiff difference_type;
    typedef int size_type;

    inline bool empty() const { return isEmpty(); }
    
    inline QSet<T> &operator<<(const T &value) { insert(value); return *this; }
    inline QSet<T> &operator|=(const QSet<T> &other) { unite(other); return *this; }
    inline QSet<T> &operator|=(const T &value) { insert(value); return *this; }
    inline QSet<T> &operator&=(const QSet<T> &other) { intersect(other); return *this; }
    inline QSet<T> &operator&=(const T &value)
        { QSet<T> result; if (contains(value)) result.insert(value); return (*this = result); }
    inline QSet<T> &operator+=(const QSet<T> &other) { unite(other); return *this; }
    inline QSet<T> &operator+=(const T &value) { insert(value); return *this; }
    inline QSet<T> &operator-=(const QSet<T> &other) { subtract(other); return *this; }
    inline QSet<T> &operator-=(const T &value) { remove(value); return *this; }
    inline QSet<T> operator|(const QSet<T> &other) const
        { QSet<T> result = *this; result |= other; return result; }
    inline QSet<T> operator&(const QSet<T> &other) const
        { QSet<T> result = *this; result &= other; return result; }
    inline QSet<T> operator+(const QSet<T> &other) const
        { QSet<T> result = *this; result += other; return result; }
    inline QSet<T> operator-(const QSet<T> &other) const
        { QSet<T> result = *this; result -= other; return result; }

    QList<T> values() const;





#line 269 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"

private:
    Hash q_hash;

    static const_iterator m2c(iterator it) noexcept
    { return const_iterator(typename Hash::const_iterator(it.i.i)); }

    bool isValidIterator(const iterator &i) const
    {
        return q_hash.isValidIterator(reinterpret_cast<const typename Hash::iterator&>(i));
    }
    bool isValidIterator(const const_iterator &i) const noexcept
    {
        return q_hash.isValidIterator(reinterpret_cast<const typename Hash::const_iterator&>(i));
    }
};


template <typename InputIterator,
          typename ValueType = typename std::iterator_traits<InputIterator>::value_type,
          QtPrivate::IfIsInputIterator<InputIterator> = true>
QSet(InputIterator, InputIterator) -> QSet<ValueType>;
#line 292 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"

template <typename T>
uint qHash(const QSet<T> &key, uint seed = 0)
noexcept(noexcept(qHashRangeCommutative(key.begin(), key.end(), seed)))
{
    return qHashRangeCommutative(key.begin(), key.end(), seed);
}



template <class T>
inline void QSet<T>::reserve(int asize) { q_hash.reserve(asize); }

template <class T>
inline QSet<T> &QSet<T>::unite(const QSet<T> &other)
{
    if (!q_hash.isSharedWith(other.q_hash)) {
        for (const T &e : other)
            insert(e);
    }
    return *this;
}

template <class T>
inline QSet<T> &QSet<T>::intersect(const QSet<T> &other)
{
    QSet<T> copy1;
    QSet<T> copy2;
    if (size() <= other.size()) {
        copy1 = *this;
        copy2 = other;
    } else {
        copy1 = other;
        copy2 = *this;
        *this = copy1;
    }
    for (const auto &e : qAsConst(copy1)) {
        if (!copy2.contains(e))
            remove(e);
    }
    return *this;
}

template <class T>
inline bool QSet<T>::intersects(const QSet<T> &other) const
{
    const bool otherIsBigger = other.size() > size();
    const QSet &smallestSet = otherIsBigger ? *this : other;
    const QSet &biggestSet = otherIsBigger ? other : *this;
    const bool equalSeeds = q_hash.d->seed == other.q_hash.d->seed;
    typename QSet::const_iterator i = smallestSet.cbegin();
    typename QSet::const_iterator e = smallestSet.cend();

    if ((equalSeeds)) {
        
        while (i != e) {
            if (*biggestSet.q_hash.findNode(*i, i.i.i->h) != biggestSet.q_hash.e)
                return true;
            ++i;
        }
    } else {
        while (i != e) {
            if (biggestSet.contains(*i))
                return true;
            ++i;
        }
     }

    return false;
}

template <class T>
inline QSet<T> &QSet<T>::subtract(const QSet<T> &other)
{
    if (q_hash.isSharedWith(other.q_hash)) {
        clear();
    } else {
        for (const auto &e : other)
            remove(e);
    }
    return *this;
}

template <class T>
inline bool QSet<T>::contains(const QSet<T> &other) const
{
    typename QSet<T>::const_iterator i = other.constBegin();
    while (i != other.constEnd()) {
        if (!contains(*i))
            return false;
        ++i;
    }
    return true;
}

template <typename T>
inline QList<T> QSet<T>::values() const
{
    QList<T> result;
    result.reserve(size());
    typename QSet<T>::const_iterator i = constBegin();
    while (i != constEnd()) {
        result.append(*i);
        ++i;
    }
    return result;
}






























#line 430 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"

template <class T> class QSetIterator { typedef typename QSet<T>::const_iterator const_iterator; QSet<T> c; const_iterator i; public: inline QSetIterator(const QSet<T> &container) : c(container), i(c.constBegin()) {} inline QSetIterator &operator=(const QSet<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };


template <typename T>
class QMutableSetIterator
{
    typedef typename QSet<T>::iterator iterator;
    QSet<T> *c;
    iterator i, n;
    inline bool item_exists() const { return c->constEnd() != n; }

public:
    inline QMutableSetIterator(QSet<T> &container)
        : c(&container)
    { i = c->begin(); n = c->end(); }
    inline QMutableSetIterator &operator=(QSet<T> &container)
    { c = &container; i = c->begin(); n = c->end(); return *this; }
    inline void toFront() { i = c->begin(); n = c->end(); }
    inline void toBack() { i = c->end(); n = i; }
    inline bool hasNext() const { return c->constEnd() != i; }
    inline const T &next() { n = i++; return *n; }
    inline const T &peekNext() const { return *i; }
    inline void remove()
    { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } }
    inline const T &value() const { ((item_exists()) ? static_cast<void>(0) : qt_assert("item_exists()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h", 455)); return *n; }
    inline bool findNext(const T &t)
    { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; }







#line 466 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
};
#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"



#line 472 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qset.h"
#pragma external_header(pop)
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h"








struct __declspec(dllimport) QContiguousCacheData
{
    QBasicAtomicInt ref;
    int alloc;
    int count;
    int start;
    int offset;
    uint sharable : 1;
    uint reserved : 31;

    
    
    
    

    static QContiguousCacheData *allocateData(int size, int alignment);
    static void freeData(QContiguousCacheData *data);




};

template <typename T>
struct QContiguousCacheTypedData: private QContiguousCacheData
{
    
    T array[1];

    static inline void freeData(QContiguousCacheTypedData *data) { QContiguousCacheData::freeData(data); }
};

template<typename T>
class QContiguousCache {
    typedef QContiguousCacheTypedData<T> Data;
    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; };
public:
    
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef qptrdiff difference_type;
    typedef int size_type;

    explicit QContiguousCache(int capacity = 0);
    QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }

    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) freeData(p); }

    inline void detach() { if (d->ref.loadRelaxed() != 1) detach_helper(); }
    inline bool isDetached() const { return d->ref.loadRelaxed() == 1; }

    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
#line 108 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h"

    QContiguousCache<T> &operator=(const QContiguousCache<T> &other);
    inline QContiguousCache<T> &operator=(QContiguousCache<T> &&other) noexcept
    { qSwap(d, other.d); return *this; }
    inline void swap(QContiguousCache<T> &other) noexcept { qSwap(d, other.d); }
    bool operator==(const QContiguousCache<T> &other) const;
    inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }

    inline int capacity() const {return d->alloc; }
    inline int count() const { return d->count; }
    inline int size() const { return d->count; }

    inline bool isEmpty() const { return d->count == 0; }
    inline bool isFull() const { return d->count == d->alloc; }
    inline int available() const { return d->alloc - d->count; }

    void clear();
    void setCapacity(int size);

    const T &at(int pos) const;
    T &operator[](int i);
    const T &operator[](int i) const;

    void append(const T &value);
    void prepend(const T &value);
    void insert(int pos, const T &value);

    inline bool containsIndex(int pos) const { return pos >= d->offset && pos - d->offset < d->count; }
    inline int firstIndex() const { return d->offset; }
    inline int lastIndex() const { return d->offset + d->count - 1; }

    inline const T &first() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 139)); return p->array[d->start]; }
    inline const T &last() const { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 140)); return p->array[(d->start + d->count -1) % d->alloc]; }
    inline T &first() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 141)); detach(); return p->array[d->start]; }
    inline T &last() { ((!isEmpty()) ? static_cast<void>(0) : qt_assert("!isEmpty()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 142)); detach(); return p->array[(d->start + d->count -1) % d->alloc]; }

    void removeFirst();
    T takeFirst();
    void removeLast();
    T takeLast();

    inline bool areIndexesValid() const
    { return d->offset >= 0 && d->offset < 2147483647 - d->count && (d->offset % d->alloc) == d->start; }

    inline void normalizeIndexes() { d->offset = d->start; }




private:
    void detach_helper();

    QContiguousCacheData *allocateData(int aalloc);
    void freeData(Data *x);
    int sizeOfTypedData() {
        
        
        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
    }
    int alignOfTypedData() const
    {
        return qMax<int>(sizeof(void*), alignof(Data));
    }
};

template <typename T>
void QContiguousCache<T>::detach_helper()
{
    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;

    x.d = allocateData(d->alloc);
    x.d->ref.storeRelaxed(1);
    x.d->count = d->count;
    x.d->start = d->start;
    x.d->offset = d->offset;
    x.d->alloc = d->alloc;
    x.d->sharable = true;
    x.d->reserved = 0;

    T *dest = x.p->array + x.d->start;
    T *src = p->array + d->start;
    int oldcount = x.d->count;
    while (oldcount--) {
        if (QTypeInfo<T>::isComplex) {
            new (dest) T(*src);
        } else {
            *dest = *src;
        }
        dest++;
        if (dest == x.p->array + x.d->alloc)
            dest = x.p->array;
        src++;
        if (src == p->array + d->alloc)
            src = p->array;
    }

    if (!d->ref.deref())
        freeData(p);
    d = x.d;
}

template <typename T>
void QContiguousCache<T>::setCapacity(int asize)
{
    ((asize >= 0) ? static_cast<void>(0) : qt_assert("asize >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 212));
    if (asize == d->alloc)
        return;
    detach();
    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
    x.d = allocateData(asize);
    x.d->ref.storeRelaxed(1);
    x.d->alloc = asize;
    x.d->count = qMin(d->count, asize);
    x.d->offset = d->offset + d->count - x.d->count;
    if(asize)
        x.d->start = x.d->offset % x.d->alloc;
    else
        x.d->start = 0;

    int oldcount = x.d->count;
    if(oldcount)
    {
        T *dest = x.p->array + (x.d->start + x.d->count-1) % x.d->alloc;
        T *src = p->array + (d->start + d->count-1) % d->alloc;
        while (oldcount--) {
            if (QTypeInfo<T>::isComplex) {
                new (dest) T(*src);
            } else {
                *dest = *src;
            }
            if (dest == x.p->array)
                dest = x.p->array + x.d->alloc;
            dest--;
            if (src == p->array)
                src = p->array + d->alloc;
            src--;
        }
    }
    
    freeData(p);
    d = x.d;
}

template <typename T>
void QContiguousCache<T>::clear()
{
    if (d->ref.loadRelaxed() == 1) {
        if (QTypeInfo<T>::isComplex) {
            int oldcount = d->count;
            T * i = p->array + d->start;
            T * e = p->array + d->alloc;
            while (oldcount--) {
                i->~T();
                i++;
                if (i == e)
                    i = p->array;
            }
        }
        d->count = d->start = d->offset = 0;
    } else {
        union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
        x.d = allocateData(d->alloc);
        x.d->ref.storeRelaxed(1);
        x.d->alloc = d->alloc;
        x.d->count = x.d->start = x.d->offset = 0;
        x.d->sharable = true;
        if (!d->ref.deref()) freeData(p);
        d = x.d;
    }
}

template <typename T>
inline QContiguousCacheData *QContiguousCache<T>::allocateData(int aalloc)
{
    return QContiguousCacheData::allocateData(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
}

template <typename T>
QContiguousCache<T>::QContiguousCache(int cap)
{
    ((cap >= 0) ? static_cast<void>(0) : qt_assert("cap >= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 288));
    d = allocateData(cap);
    d->ref.storeRelaxed(1);
    d->alloc = cap;
    d->count = d->start = d->offset = 0;
    d->sharable = true;
}

template <typename T>
QContiguousCache<T> &QContiguousCache<T>::operator=(const QContiguousCache<T> &other)
{
    other.d->ref.ref();
    if (!d->ref.deref())
        freeData(p);
    d = other.d;
    if (!d->sharable)
        detach_helper();
    return *this;
}

template <typename T>
bool QContiguousCache<T>::operator==(const QContiguousCache<T> &other) const
{
    if (other.d == d)
        return true;
    if (other.d->start != d->start
            || other.d->count != d->count
            || other.d->offset != d->offset
            || other.d->alloc != d->alloc)
        return false;
    for (int i = firstIndex(); i <= lastIndex(); ++i)
        if (!(at(i) == other.at(i)))
            return false;
    return true;
}

template <typename T>
void QContiguousCache<T>::freeData(Data *x)
{
    if (QTypeInfo<T>::isComplex) {
        int oldcount = d->count;
        T * i = p->array + d->start;
        T * e = p->array + d->alloc;
        while (oldcount--) {
            i->~T();
            i++;
            if (i == e)
                i = p->array;
        }
    }
    x->freeData(x);
}
template <typename T>
void QContiguousCache<T>::append(const T &value)
{
    if (!d->alloc)
        return;     
    detach();
    if (QTypeInfo<T>::isComplex) {
        if (d->count == d->alloc)
            (p->array + (d->start+d->count) % d->alloc)->~T();
        new (p->array + (d->start+d->count) % d->alloc) T(value);
    } else {
        p->array[(d->start+d->count) % d->alloc] = value;
    }

    if (d->count == d->alloc) {
        d->start++;
        d->start %= d->alloc;
        d->offset++;
    } else {
        d->count++;
    }
}

template<typename T>
void QContiguousCache<T>::prepend(const T &value)
{
    if (!d->alloc)
        return;     
    detach();
    if (d->start)
        d->start--;
    else
        d->start = d->alloc-1;
    d->offset--;

    if (d->count != d->alloc)
        d->count++;
    else
        if (d->count == d->alloc)
            (p->array + d->start)->~T();

    if (QTypeInfo<T>::isComplex)
        new (p->array + d->start) T(value);
    else
        p->array[d->start] = value;
}

template<typename T>
void QContiguousCache<T>::insert(int pos, const T &value)
{
    ((pos >= 0 && pos < 2147483647) ? static_cast<void>(0) : qt_assert_x("QContiguousCache<T>::insert", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 390));
    if (!d->alloc)
        return;     
    detach();
    if (containsIndex(pos)) {
        if (QTypeInfo<T>::isComplex) {
            (p->array + pos % d->alloc)->~T();
            new (p->array + pos % d->alloc) T(value);
        } else {
            p->array[pos % d->alloc] = value;
        }
    } else if (pos == d->offset-1)
        prepend(value);
    else if (pos == d->offset+d->count)
        append(value);
    else {
        
        clear();
        d->offset = pos;
        d->start = pos % d->alloc;
        d->count = 1;
        if (QTypeInfo<T>::isComplex)
            new (p->array + d->start) T(value);
        else
            p->array[d->start] = value;
    }
}

template <typename T>
inline const T &QContiguousCache<T>::at(int pos) const
{ ((pos >= d->offset && pos - d->offset < d->count) ? static_cast<void>(0) : qt_assert_x("QContiguousCache<T>::at", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 420)); return p->array[pos % d->alloc]; }
template <typename T>
inline const T &QContiguousCache<T>::operator[](int pos) const
{ ((pos >= d->offset && pos - d->offset < d->count) ? static_cast<void>(0) : qt_assert_x("QContiguousCache<T>::at", "index out of range", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 423)); return p->array[pos % d->alloc]; }

template <typename T>
inline T &QContiguousCache<T>::operator[](int pos)
{
    detach();
    if (!containsIndex(pos))
        insert(pos, T());
    return p->array[pos % d->alloc];
}

template <typename T>
inline void QContiguousCache<T>::removeFirst()
{
    ((d->count > 0) ? static_cast<void>(0) : qt_assert("d->count > 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 437));
    detach();
    d->count--;
    if (QTypeInfo<T>::isComplex)
        (p->array + d->start)->~T();
    d->start = (d->start + 1) % d->alloc;
    d->offset++;
}

template <typename T>
inline void QContiguousCache<T>::removeLast()
{
    ((d->count > 0) ? static_cast<void>(0) : qt_assert("d->count > 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h", 449));
    detach();
    d->count--;
    if (QTypeInfo<T>::isComplex)
        (p->array + (d->start + d->count) % d->alloc)->~T();
}

template <typename T>
inline T QContiguousCache<T>::takeFirst()
{ T t = first(); removeFirst(); return t; }

template <typename T>
inline T QContiguousCache<T>::takeLast()
{ T t = last(); removeLast(); return t; }



#line 467 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qcontiguouscache.h"
#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer.h"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"


















































#line 52 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"









#line 62 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qatomic.h"



















































































































































































































































































#pragma external_header(pop)
#line 65 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"



#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"









template <class T> class QWeakPointer;
template <class T> class QSharedPointer;
template <class T> class QEnableSharedFromThis;

class QVariant;

template <class X, class T>
QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &ptr);
template <class X, class T>
QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &ptr);
template <class X, class T>
QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &ptr);


template <class X, class T>
QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &ptr);
#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

namespace QtPrivate {
struct EnableInternalData;
}

namespace QtSharedPointer {
    template <class T> class ExternalRefCount;

    template <class X, class Y> QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);

    
    __declspec(dllimport) void internalSafetyCheckAdd(const void *, const volatile void *);
    __declspec(dllimport) void internalSafetyCheckRemove(const void *);

    template <class T, typename Klass, typename RetVal>
    inline void executeDeleter(T *t, RetVal (Klass:: *memberDeleter)())
    { if (t) (t->*memberDeleter)(); }
    template <class T, typename Deleter>
    inline void executeDeleter(T *t, Deleter d)
    { d(t); }
    struct NormalDeleter {};

    
    template <class T> struct RemovePointer;
    template <class T> struct RemovePointer<T *> { typedef T Type; };
    template <class T> struct RemovePointer<QSharedPointer<T> > { typedef T Type; };
    template <class T> struct RemovePointer<QWeakPointer<T> > { typedef T Type; };

    
    
    
    
    
    
    
    
    
    
    struct ExternalRefCountData
    {
        typedef void (*DestroyerFn)(ExternalRefCountData *);
        QBasicAtomicInt weakref;
        QBasicAtomicInt strongref;
        DestroyerFn destroyer;

        inline ExternalRefCountData(DestroyerFn d)
            : destroyer(d)
        {
            strongref.storeRelaxed(1);
            weakref.storeRelaxed(1);
        }
        inline ExternalRefCountData(Qt::Initialization) { }
        ~ExternalRefCountData() { ((!weakref.loadRelaxed()) ? static_cast<void>(0) : qt_assert("!weakref.loadRelaxed()", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h", 147)); ((strongref.loadRelaxed() <= 0) ? static_cast<void>(0) : qt_assert("strongref.loadRelaxed() <= 0", "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h", 147)); }

        void destroy() { destroyer(this); }


        __declspec(dllimport) static ExternalRefCountData *getAndRef(const QObject *);
        __declspec(dllimport) void setQObjectShared(const QObject *, bool enable);
        __declspec(dllimport) void checkQObjectShared(const QObject *);
#line 156 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
        inline void checkQObjectShared(...) { }
        inline void setQObjectShared(...) { }

        
        
        
        inline void *operator new(std::size_t) = delete;
        
        inline void *operator new(std::size_t, void *ptr) noexcept { return ptr; }
        inline void operator delete(void *ptr) { ::operator delete(ptr); }
        inline void operator delete(void *, void *) { }
    };
    

    template <class T, typename Deleter>
    struct CustomDeleter
    {
        Deleter deleter;
        T *ptr;

        CustomDeleter(T *p, Deleter d) : deleter(d), ptr(p) {}
        void execute() { executeDeleter(ptr, deleter); }
    };
    
    
    
    

    
    
    
    template <class T>
    struct CustomDeleter<T, NormalDeleter>
    {
        T *ptr;

        CustomDeleter(T *p, NormalDeleter) : ptr(p) {}
        void execute() { delete ptr; }
    };
    

    
    
    
    
    template <class T, typename Deleter>
    struct ExternalRefCountWithCustomDeleter: public ExternalRefCountData
    {
        typedef ExternalRefCountWithCustomDeleter Self;
        typedef ExternalRefCountData BaseClass;
        CustomDeleter<T, Deleter> extra;

        static inline void deleter(ExternalRefCountData *self)
        {
            Self *realself = static_cast<Self *>(self);
            realself->extra.execute();

            
            realself->extra.~CustomDeleter<T, Deleter>();
        }
        static void safetyCheckDeleter(ExternalRefCountData *self)
        {
            internalSafetyCheckRemove(self);
            deleter(self);
        }

        static inline Self *create(T *ptr, Deleter userDeleter, DestroyerFn actualDeleter)
        {
            Self *d = static_cast<Self *>(::operator new(sizeof(Self)));

            
            new (&d->extra) CustomDeleter<T, Deleter>(ptr, userDeleter);
            new (d) BaseClass(actualDeleter); 

            return d;
        }
    private:
        
        ExternalRefCountWithCustomDeleter() = delete;
        ~ExternalRefCountWithCustomDeleter() = delete;
        ExternalRefCountWithCustomDeleter(const ExternalRefCountWithCustomDeleter &) = delete; ExternalRefCountWithCustomDeleter &operator=(const ExternalRefCountWithCustomDeleter &) = delete;
    };

    
    
    
    
    template <class T>
    struct ExternalRefCountWithContiguousData: public ExternalRefCountData
    {
        typedef ExternalRefCountData Parent;
        typedef typename std::remove_cv<T>::type NoCVType;
        NoCVType data;

        static void deleter(ExternalRefCountData *self)
        {
            ExternalRefCountWithContiguousData *that =
                    static_cast<ExternalRefCountWithContiguousData *>(self);
            that->data.~T();
            (void)that;; 
        }
        static void safetyCheckDeleter(ExternalRefCountData *self)
        {
            internalSafetyCheckRemove(self);
            deleter(self);
        }
        static void noDeleter(ExternalRefCountData *) { }

        static inline ExternalRefCountData *create(NoCVType **ptr, DestroyerFn destroy)
        {
            ExternalRefCountWithContiguousData *d =
                static_cast<ExternalRefCountWithContiguousData *>(::operator new(sizeof(ExternalRefCountWithContiguousData)));

            
            
            new (d) Parent(destroy); 

            *ptr = &d->data;
            return d;
        }

    private:
        
        ExternalRefCountWithContiguousData() = delete;
        ~ExternalRefCountWithContiguousData() = delete;
        ExternalRefCountWithContiguousData(const ExternalRefCountWithContiguousData &) = delete; ExternalRefCountWithContiguousData &operator=(const ExternalRefCountWithContiguousData &) = delete;
    };


    __declspec(dllimport) QWeakPointer<QObject> weakPointerFromVariant_internal(const QVariant &variant);
    __declspec(dllimport) QSharedPointer<QObject> sharedPointerFromVariant_internal(const QVariant &variant);
#line 288 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
} 

template <class T> class QSharedPointer
{
    typedef T *QSharedPointer:: *RestrictedBool;
    typedef QtSharedPointer::ExternalRefCountData Data;
    template <typename X>
    using IfCompatible = typename std::enable_if<std::is_convertible<X*, T*>::value, bool>::type;

public:
    typedef T Type;
    typedef T element_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef qptrdiff difference_type;

    T *data() const noexcept { return value; }
    T *get() const noexcept { return value; }
    bool isNull() const noexcept { return !data(); }
    operator RestrictedBool() const noexcept { return isNull() ? nullptr : &QSharedPointer::value; }
    bool operator !() const noexcept { return isNull(); }
    T &operator*() const { return *data(); }
    T *operator->() const noexcept { return data(); }

    constexpr QSharedPointer() noexcept : value(nullptr), d(nullptr) { }
    ~QSharedPointer() { deref(); }

    constexpr QSharedPointer(std::nullptr_t) noexcept : value(nullptr), d(nullptr) { }

    template <class X, IfCompatible<X> = true>
    inline explicit QSharedPointer(X *ptr) : value(ptr) 
    { internalConstruct(ptr, QtSharedPointer::NormalDeleter()); }

    template <class X, typename Deleter, IfCompatible<X> = true>
    inline QSharedPointer(X *ptr, Deleter deleter) : value(ptr) 
    { internalConstruct(ptr, deleter); }

    template <typename Deleter>
    QSharedPointer(std::nullptr_t, Deleter deleter) : value(nullptr)
    { internalConstruct(static_cast<T *>(nullptr), deleter); }

    QSharedPointer(const QSharedPointer &other) noexcept : value(other.value), d(other.d)
    { if (d) ref(); }
    QSharedPointer &operator=(const QSharedPointer &other) noexcept
    {
        QSharedPointer copy(other);
        swap(copy);
        return *this;
    }
    QSharedPointer(QSharedPointer &&other) noexcept
        : value(other.value), d(other.d)
    {
        other.d = nullptr;
        other.value = nullptr;
    }
    QSharedPointer &operator=(QSharedPointer &&other) noexcept
    {
        QSharedPointer moved(std::move(other));
        swap(moved);
        return *this;
    }

    template <class X, IfCompatible<X> = true>
    QSharedPointer(QSharedPointer<X> &&other) noexcept
        : value(other.value), d(other.d)
    {
        other.d = nullptr;
        other.value = nullptr;
    }

    template <class X, IfCompatible<X> = true>
    QSharedPointer &operator=(QSharedPointer<X> &&other) noexcept
    {
        QSharedPointer moved(std::move(other));
        swap(moved);
        return *this;
    }

    template <class X, IfCompatible<X> = true>
    QSharedPointer(const QSharedPointer<X> &other) noexcept : value(other.value), d(other.d)
    { if (d) ref(); }

    template <class X, IfCompatible<X> = true>
    inline QSharedPointer &operator=(const QSharedPointer<X> &other)
    {
        QSharedPointer copy(other);
        swap(copy);
        return *this;
    }

    template <class X, IfCompatible<X> = true>
    inline QSharedPointer(const QWeakPointer<X> &other) : value(nullptr), d(nullptr)
    { *this = other; }

    template <class X, IfCompatible<X> = true>
    inline QSharedPointer<T> &operator=(const QWeakPointer<X> &other)
    { internalSet(other.d, other.value); return *this; }

    inline void swap(QSharedPointer &other) noexcept
    { this->internalSwap(other); }

    inline void reset() { clear(); }
    inline void reset(T *t)
    { QSharedPointer copy(t); swap(copy); }
    template <typename Deleter>
    inline void reset(T *t, Deleter deleter)
    { QSharedPointer copy(t, deleter); swap(copy); }

    template <class X>
    QSharedPointer<X> staticCast() const
    {
        return qSharedPointerCast<X, T>(*this);
    }

    template <class X>
    QSharedPointer<X> dynamicCast() const
    {
        return qSharedPointerDynamicCast<X, T>(*this);
    }

    template <class X>
    QSharedPointer<X> constCast() const
    {
        return qSharedPointerConstCast<X, T>(*this);
    }


    template <class X>
    QSharedPointer<X> objectCast() const
    {
        return qSharedPointerObjectCast<X, T>(*this);
    }
#line 424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

    inline void clear() { QSharedPointer copy; swap(copy); }

    QWeakPointer<T> toWeakRef() const;

    template <typename... Args>
    static QSharedPointer create(Args && ...arguments)
    {
        typedef QtSharedPointer::ExternalRefCountWithContiguousData<T> Private;



        typename Private::DestroyerFn destroy = &Private::deleter;
#line 438 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
        typename Private::DestroyerFn noDestroy = &Private::noDeleter;
        QSharedPointer result(Qt::Uninitialized);
        typename std::remove_cv<T>::type *ptr;
        result.d = Private::create(&ptr, noDestroy);

        
        new (ptr) T(std::forward<Args>(arguments)...);
        result.value = ptr;
        result.d->destroyer = destroy;
        result.d->setQObjectShared(result.value, true);



        result.enableSharedFromThis(result.data());
        return result;
    }

private:
    explicit QSharedPointer(Qt::Initialization) {}

    void deref() noexcept
    { deref(d); }
    static void deref(Data *dd) noexcept
    {
        if (!dd) return;
        if (!dd->strongref.deref()) {
            dd->destroy();
        }
        if (!dd->weakref.deref())
            delete dd;
    }

    template <class X>
    inline void enableSharedFromThis(const QEnableSharedFromThis<X> *ptr)
    {
        ptr->initializeFromSharedPointer(constCast<typename std::remove_cv<T>::type>());
    }

    inline void enableSharedFromThis(...) {}

    template <typename X, typename Deleter>
    inline void internalConstruct(X *ptr, Deleter deleter)
    {
        typedef QtSharedPointer::ExternalRefCountWithCustomDeleter<X, Deleter> Private;



        typename Private::DestroyerFn actualDeleter = &Private::deleter;
#line 487 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
        d = Private::create(ptr, deleter, actualDeleter);




        d->setQObjectShared(ptr, true);
        enableSharedFromThis(ptr);
    }

    void internalSwap(QSharedPointer &other) noexcept
    {
        qSwap(d, other.d);
        qSwap(this->value, other.value);
    }



#line 505 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
    template <class X> friend class QSharedPointer;
    template <class X> friend class QWeakPointer;
    template <class X, class Y> friend QSharedPointer<X> QtSharedPointer::copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
#line 509 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
    void ref() const noexcept { d->weakref.ref(); d->strongref.ref(); }

    inline void internalSet(Data *o, T *actual)
    {
        if (o) {
            
            
            int tmp = o->strongref.loadRelaxed();
            while (tmp > 0) {
                
                if (o->strongref.testAndSetRelaxed(tmp, tmp + 1))
                    break;   
                tmp = o->strongref.loadRelaxed();  
            }

            if (tmp > 0) {
                o->weakref.ref();
            } else {
                o->checkQObjectShared(actual);
                o = nullptr;
            }
        }

        qSwap(d, o);
        qSwap(this->value, actual);
        if (!d || d->strongref.loadRelaxed() == 0)
            this->value = nullptr;

        
        deref(o);
    }

    Type *value;
    Data *d;
};

template <class T>
class QWeakPointer
{
    typedef T *QWeakPointer:: *RestrictedBool;
    typedef QtSharedPointer::ExternalRefCountData Data;
    template <typename X>
    using IfCompatible = typename std::enable_if<std::is_convertible<X*, T*>::value, bool>::type;

public:
    typedef T element_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef qptrdiff difference_type;

    bool isNull() const noexcept { return d == nullptr || d->strongref.loadRelaxed() == 0 || value == nullptr; }
    operator RestrictedBool() const noexcept { return isNull() ? nullptr : &QWeakPointer::value; }
    bool operator !() const noexcept { return isNull(); }




#line 570 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

    inline QWeakPointer() noexcept : d(nullptr), value(nullptr) { }
    inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }


    




#line 581 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
#line 582 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"





#line 588 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

    QWeakPointer(const QWeakPointer &other) noexcept : d(other.d), value(other.value)
    { if (d) d->weakref.ref(); }
    QWeakPointer(QWeakPointer &&other) noexcept
        : d(other.d), value(other.value)
    {
        other.d = nullptr;
        other.value = nullptr;
    }
    QWeakPointer &operator=(QWeakPointer &&other) noexcept
    { QWeakPointer moved(std::move(other)); swap(moved); return *this; }
    QWeakPointer &operator=(const QWeakPointer &other) noexcept
    {
        QWeakPointer copy(other);
        swap(copy);
        return *this;
    }

    void swap(QWeakPointer &other) noexcept
    {
        qSwap(this->d, other.d);
        qSwap(this->value, other.value);
    }

    inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
    { if (d) d->weakref.ref();}
    inline QWeakPointer &operator=(const QSharedPointer<T> &o)
    {
        internalSet(o.d, o.value);
        return *this;
    }

    template <class X, IfCompatible<X> = true>
    inline QWeakPointer(const QWeakPointer<X> &o) : d(nullptr), value(nullptr)
    { *this = o; }

    template <class X, IfCompatible<X> = true>
    inline QWeakPointer &operator=(const QWeakPointer<X> &o)
    {
        
        
        *this = o.toStrongRef();
        return *this;
    }

    template <class X>
    bool operator==(const QWeakPointer<X> &o) const noexcept
    { return d == o.d && value == static_cast<const T *>(o.value); }

    template <class X>
    bool operator!=(const QWeakPointer<X> &o) const noexcept
    { return !(*this == o); }

    template <class X, IfCompatible<X> = true>
    inline QWeakPointer(const QSharedPointer<X> &o) : d(nullptr), value(nullptr)
    { *this = o; }

    template <class X, IfCompatible<X> = true>
    inline QWeakPointer &operator=(const QSharedPointer<X> &o)
    {
        internalSet(o.d, o.data());
        return *this;
    }

    template <class X>
    bool operator==(const QSharedPointer<X> &o) const noexcept
    { return d == o.d; }

    template <class X>
    bool operator!=(const QSharedPointer<X> &o) const noexcept
    { return !(*this == o); }

    inline void clear() { *this = QWeakPointer(); }

    inline QSharedPointer<T> toStrongRef() const { return QSharedPointer<T>(*this); }
    
    inline QSharedPointer<T> lock() const { return toStrongRef(); }



#line 669 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

private:
    friend struct QtPrivate::EnableInternalData;


#line 675 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
    template <class X> friend class QSharedPointer;
    template <class X> friend class QPointer;
#line 678 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

    template <class X>
    inline QWeakPointer &assign(X *ptr)
    { return *this = QWeakPointer<X>(ptr, true); }


    template <class X, IfCompatible<X> = true>
    inline QWeakPointer(X *ptr, bool) : d(ptr ? Data::getAndRef(ptr) : nullptr), value(ptr)
    { }
#line 688 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

    inline void internalSet(Data *o, T *actual)
    {
        if (d == o) return;
        if (o)
            o->weakref.ref();
        if (d && !d->weakref.deref())
            delete d;
        d = o;
        value = actual;
    }

    
    
    inline T *internalData() const noexcept
    {
        return d == nullptr || d->strongref.loadRelaxed() == 0 ? nullptr : value;
    }

    Data *d;
    T *value;
};

namespace QtPrivate {
struct EnableInternalData {
    template <typename T>
    static T *internalData(const QWeakPointer<T> &p) noexcept { return p.internalData(); }
};


template <typename T>
struct EnableInternalDataWrap : EnableInternalData {};
}

template <class T>
class QEnableSharedFromThis
{
protected:
    QEnableSharedFromThis() = default;
    QEnableSharedFromThis(const QEnableSharedFromThis &) {}
    QEnableSharedFromThis &operator=(const QEnableSharedFromThis &) { return *this; }

public:
    inline QSharedPointer<T> sharedFromThis() { return QSharedPointer<T>(weakPointer); }
    inline QSharedPointer<const T> sharedFromThis() const { return QSharedPointer<const T>(weakPointer); }


private:
    template <class X> friend class QSharedPointer;


#line 740 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
    template <class X>
    inline void initializeFromSharedPointer(const QSharedPointer<X> &ptr) const
    {
        weakPointer = ptr;
    }

    mutable QWeakPointer<T> weakPointer;
};




template <class T, class X>
bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2) noexcept
{
    return ptr1.data() == ptr2.data();
}
template <class T, class X>
bool operator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2) noexcept
{
    return ptr1.data() != ptr2.data();
}

template <class T, class X>
bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2) noexcept
{
    return ptr1.data() == ptr2;
}
template <class T, class X>
bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2) noexcept
{
    return ptr1 == ptr2.data();
}
template <class T, class X>
bool operator!=(const QSharedPointer<T> &ptr1, const X *ptr2) noexcept
{
    return !(ptr1 == ptr2);
}
template <class T, class X>
bool operator!=(const T *ptr1, const QSharedPointer<X> &ptr2) noexcept
{
    return !(ptr2 == ptr1);
}

template <class T, class X>
bool operator==(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2) noexcept
{
    return ptr2 == ptr1;
}
template <class T, class X>
bool operator!=(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2) noexcept
{
    return ptr2 != ptr1;
}

template<class T>
inline bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t) noexcept
{
    return lhs.isNull();
}

template<class T>
inline bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t) noexcept
{
    return !lhs.isNull();
}

template<class T>
inline bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs) noexcept
{
    return rhs.isNull();
}

template<class T>
inline bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs) noexcept
{
    return !rhs.isNull();
}

template<class T>
inline bool operator==(const QWeakPointer<T> &lhs, std::nullptr_t) noexcept
{
    return lhs.isNull();
}

template<class T>
inline bool operator!=(const QWeakPointer<T> &lhs, std::nullptr_t) noexcept
{
    return !lhs.isNull();
}

template<class T>
inline bool operator==(std::nullptr_t, const QWeakPointer<T> &rhs) noexcept
{
    return rhs.isNull();
}

template<class T>
inline bool operator!=(std::nullptr_t, const QWeakPointer<T> &rhs) noexcept
{
    return !rhs.isNull();
}




template <class T, class X>
inline typename QSharedPointer<T>::difference_type operator-(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
{
    return ptr1.data() - ptr2.data();
}
template <class T, class X>
inline typename QSharedPointer<T>::difference_type operator-(const QSharedPointer<T> &ptr1, X *ptr2)
{
    return ptr1.data() - ptr2;
}
template <class T, class X>
inline typename QSharedPointer<X>::difference_type operator-(T *ptr1, const QSharedPointer<X> &ptr2)
{
    return ptr1 - ptr2.data();
}




template <class T, class X>
inline bool operator<(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
{
    using CT = typename std::common_type<T *, X *>::type;
    return std::less<CT>()(ptr1.data(), ptr2.data());
}
template <class T, class X>
inline bool operator<(const QSharedPointer<T> &ptr1, X *ptr2)
{
    using CT = typename std::common_type<T *, X *>::type;
    return std::less<CT>()(ptr1.data(), ptr2);
}
template <class T, class X>
inline bool operator<(T *ptr1, const QSharedPointer<X> &ptr2)
{
    using CT = typename std::common_type<T *, X *>::type;
    return std::less<CT>()(ptr1, ptr2.data());
}




template <class T>
inline uint qHash(const QSharedPointer<T> &ptr, uint seed = 0)
{
    return qHash(ptr.data(), seed);
}


template <class T>
inline QWeakPointer<T> QSharedPointer<T>::toWeakRef() const
{
    return QWeakPointer<T>(*this);
}

template <class T>
inline void swap(QSharedPointer<T> &p1, QSharedPointer<T> &p2) noexcept
{ p1.swap(p2); }

template <class T>
inline void swap(QWeakPointer<T> &p1, QWeakPointer<T> &p2) noexcept
{ p1.swap(p2); }

namespace QtSharedPointer {

    template <class X, class T>
    inline QSharedPointer<X> copyAndSetPointer(X *ptr, const QSharedPointer<T> &src)
    {
        QSharedPointer<X> result;
        result.internalSet(src.d, ptr);
        return result;
    }
}


template <class X, class T>
inline QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &src)
{
    X *ptr = static_cast<X *>(src.data()); 
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &src)
{
    return qSharedPointerCast<X, T>(src.toStrongRef());
}

template <class X, class T>
inline QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
{
    X *ptr = dynamic_cast<X *>(src.data()); 
    if (!ptr)
        return QSharedPointer<X>();
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
{
    return qSharedPointerDynamicCast<X, T>(src.toStrongRef());
}

template <class X, class T>
inline QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
{
    X *ptr = const_cast<X *>(src.data()); 
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
{
    return qSharedPointerConstCast<X, T>(src.toStrongRef());
}

template <class X, class T>
inline
QWeakPointer<X> qWeakPointerCast(const QSharedPointer<T> &src)
{
    return qSharedPointerCast<X, T>(src).toWeakRef();
}


template <class X, class T>
inline QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
{
    X *ptr = qobject_cast<X *>(src.data());
    return QtSharedPointer::copyAndSetPointer(ptr, src);
}
template <class X, class T>
inline QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
{
    return qSharedPointerObjectCast<X>(src.toStrongRef());
}

template <class X, class T>
inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
qobject_cast(const QSharedPointer<T> &src)
{
    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
}
template <class X, class T>
inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
qobject_cast(const QWeakPointer<T> &src)
{
    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
}



template<typename T>
QWeakPointer<typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value, T>::type>
qWeakPointerFromVariant(const QVariant &variant)
{
    return QWeakPointer<T>(qobject_cast<T*>(QtPrivate::EnableInternalData::internalData(QtSharedPointer::weakPointerFromVariant_internal(variant))));
}
template<typename T>
QSharedPointer<typename std::enable_if<QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value, T>::type>
qSharedPointerFromVariant(const QVariant &variant)
{
    return qSharedPointerObjectCast<T>(QtSharedPointer::sharedPointerFromVariant_internal(variant));
}



template <typename X, class T>
std::shared_ptr<X> qobject_pointer_cast(const std::shared_ptr<T> &src)
{
    using element_type = typename std::shared_ptr<X>::element_type;
    return std::shared_ptr<X>(src, qobject_cast<element_type *>(src.get()));
}

template <typename X, class T>
std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T> &&src)
{
    using element_type = typename std::shared_ptr<X>::element_type;
    auto castResult = qobject_cast<element_type *>(src.get());
    if (castResult) {
        
        
        
        
        return std::shared_ptr<X>(qExchange(src, nullptr), castResult);
    }
    return std::shared_ptr<X>();
}

template <typename X, class T>
std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T> &src)
{
    return qobject_pointer_cast<X>(src);
}

template <typename X, class T>
std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<T> &&src)
{
    return qobject_pointer_cast<X>(std::move(src));
}

#line 1043 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"

template<typename T> class QTypeInfo<QWeakPointer<T> > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QWeakPointer<T>>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QWeakPointer<T>>(), isLarge = (sizeof(QWeakPointer<T>)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QWeakPointer<T> >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QWeakPointer<T>) }; static inline const char *name() { return "QWeakPointer<T>"; } };
template<typename T> class QTypeInfo<QSharedPointer<T> > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QSharedPointer<T>>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QSharedPointer<T>>(), isLarge = (sizeof(QSharedPointer<T>)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QSharedPointer<T> >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QSharedPointer<T>) }; static inline const char *name() { return "QSharedPointer<T>"; } };




#line 1051 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer_impl.h"
#pragma external_header(pop)
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer.h"




































































































































#line 182 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer.h"

#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qsharedpointer.h"
#pragma external_header(pop)
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"










class __declspec(dllimport) QDebug
{
    friend class QMessageLogger;
    friend class QDebugStateSaver;
    friend class QDebugStateSaverPrivate;
    struct Stream {
        enum { VerbosityShift = 29, VerbosityMask = 0x7 };

        Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg),
            space(true), message_output(false), flags(DefaultVerbosity << VerbosityShift) {}
        Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg),
            space(true), message_output(false), flags(DefaultVerbosity << VerbosityShift) {}
        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t),
            space(true), message_output(true), flags(DefaultVerbosity << VerbosityShift) {}
        QTextStream ts;
        QString buffer;
        int ref;
        QtMsgType type;
        bool space;
        bool message_output;
        QMessageLogContext context;

        enum FormatFlag { 
            NoQuotes = 0x1
        };

        
        bool testFlag(FormatFlag flag) const { return (context.version > 1) ? (flags & flag) : false; }
        void setFlag(FormatFlag flag) { if (context.version > 1) { flags |= flag; } }
        void unsetFlag(FormatFlag flag) { if (context.version > 1) { flags &= ~flag; } }
        int verbosity() const
        { return context.version > 1 ? (flags >> VerbosityShift) & VerbosityMask : int(DefaultVerbosity); }
        void setVerbosity(int v)
        {
            if (context.version > 1) {
                flags &= ~(uint(VerbosityMask) << VerbosityShift);
                flags |= (v & VerbosityMask) << VerbosityShift;
            }
        }
        
        int flags;
    } *stream;

    enum Latin1Content { ContainsBinary = 0, ContainsLatin1 };

    void putUcs4(uint ucs4);
    void putString(const QChar *begin, size_t length);
    void putByteArray(const char *begin, size_t length, Latin1Content content);
public:
    inline QDebug(QIODevice *device) : stream(new Stream(device)) {}
    inline QDebug(QString *string) : stream(new Stream(string)) {}
    inline QDebug(QtMsgType t) : stream(new Stream(t)) {}
    inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; }
    QDebug(QDebug &&other) noexcept : stream{qExchange(other.stream, nullptr)} {}
    inline QDebug &operator=(const QDebug &other);
    QDebug &operator=(QDebug &&other) noexcept
    { QDebug{std::move(other)}.swap(*this); return *this; }
    ~QDebug();
    inline void swap(QDebug &other) noexcept { qSwap(stream, other.stream); }

    QDebug &resetFormat();

    inline QDebug &space() { stream->space = true; stream->ts << ' '; return *this; }
    inline QDebug &nospace() { stream->space = false; return *this; }
    inline QDebug &maybeSpace() { if (stream->space) stream->ts << ' '; return *this; }
    inline QDebug &verbosity(int verbosityLevel) { setVerbosity(verbosityLevel); return *this; }
    int verbosity() const { return stream->verbosity(); }
    void setVerbosity(int verbosityLevel) { stream->setVerbosity(verbosityLevel); }
    enum VerbosityLevel { MinimumVerbosity = 0, DefaultVerbosity = 2, MaximumVerbosity = 7 };

    bool autoInsertSpaces() const { return stream->space; }
    void setAutoInsertSpaces(bool b) { stream->space = b; }

    inline QDebug &quote() { stream->unsetFlag(Stream::NoQuotes); return *this; }
    inline QDebug &noquote() { stream->setFlag(Stream::NoQuotes); return *this; }
    inline QDebug &maybeQuote(char c = '"') { if (!(stream->testFlag(Stream::NoQuotes))) stream->ts << c; return *this; }

    inline QDebug &operator<<(QChar t) { putUcs4(t.unicode()); return maybeSpace(); }
    inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
    inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }

    inline QDebug &operator<<(char16_t t) { return *this << QChar(ushort(t)); }
    inline QDebug &operator<<(char32_t t) { putUcs4(t); return maybeSpace(); }
#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
    inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(qint64 t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(quint64 t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(const char* t) { stream->ts << QString::fromUtf8(t); return maybeSpace(); }

    inline QDebug &operator<<(const QString & t) { putString(t.constData(), uint(t.length())); return maybeSpace(); }
    inline QDebug &operator<<(const QStringRef & t) { putString(t.constData(), uint(t.length())); return maybeSpace(); }
#line 164 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
    inline QDebug &operator<<(QStringView s) { putString(s.data(), size_t(s.size())); return maybeSpace(); }
    inline QDebug &operator<<(QLatin1String t) { putByteArray(t.latin1(), t.size(), ContainsLatin1); return maybeSpace(); }
    inline QDebug &operator<<(const QByteArray & t) { putByteArray(t.constData(), t.size(), ContainsBinary); return maybeSpace(); }
    inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); }
    inline QDebug &operator<<(std::nullptr_t) { stream->ts << "(nullptr)"; return maybeSpace(); }
    inline QDebug &operator<<(QTextStreamFunction f) {
        stream->ts << f;
        return *this;
    }

    inline QDebug &operator<<(QTextStreamManipulator m)
    { stream->ts << m; return *this; }
};

template<> class QTypeInfo<QDebug > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QDebug>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QDebug>(), isLarge = (sizeof(QDebug)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QDebug >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QDebug) }; static inline const char *name() { return "QDebug"; } }; inline void swap(QDebug &value1, QDebug &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }

class QDebugStateSaverPrivate;
class __declspec(dllimport) QDebugStateSaver
{
public:
    QDebugStateSaver(QDebug &dbg);
    ~QDebugStateSaver();
private:
    QDebugStateSaver(const QDebugStateSaver &) = delete; QDebugStateSaver &operator=(const QDebugStateSaver &) = delete;
    QScopedPointer<QDebugStateSaverPrivate> d;
};

class QNoDebug
{
public:
    inline QNoDebug &operator<<(QTextStreamFunction) { return *this; }
    inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; }
    inline QNoDebug &space() { return *this; }
    inline QNoDebug &nospace() { return *this; }
    inline QNoDebug &maybeSpace() { return *this; }
    inline QNoDebug &quote() { return *this; }
    inline QNoDebug &noquote() { return *this; }
    inline QNoDebug &maybeQuote(const char = '"') { return *this; }
    inline QNoDebug &verbosity(int) { return *this; }

    template<typename T>
    inline QNoDebug &operator<<(const T &) { return *this; }
};

inline QDebug &QDebug::operator=(const QDebug &other)
{
    QDebug{other}.swap(*this);
    return *this;
}

namespace QtPrivate {

template <typename SequentialContainer>
inline QDebug printSequentialContainer(QDebug debug, const char *which, const SequentialContainer &c)
{
    const bool oldSetting = debug.autoInsertSpaces();
    debug.nospace() << which << '(';
    typename SequentialContainer::const_iterator it = c.begin(), end = c.end();
    if (it != end) {
        debug << *it;
        ++it;
    }
    while (it != end) {
        debug << ", " << *it;
        ++it;
    }
    debug << ')';
    debug.setAutoInsertSpaces(oldSetting);
    return debug.maybeSpace();
}

} 

template <class T>
inline QDebug operator<<(QDebug debug, const QList<T> &list)
{
    return QtPrivate::printSequentialContainer(debug, "" , list);
}

template <typename T>
inline QDebug operator<<(QDebug debug, const QVector<T> &vec)
{
    return QtPrivate::printSequentialContainer(debug, "QVector", vec);
}

template <typename T, typename Alloc>
inline QDebug operator<<(QDebug debug, const std::vector<T, Alloc> &vec)
{
    return QtPrivate::printSequentialContainer(debug, "std::vector", vec);
}

template <typename T, typename Alloc>
inline QDebug operator<<(QDebug debug, const std::list<T, Alloc> &vec)
{
    return QtPrivate::printSequentialContainer(debug, "std::list", vec);
}

template <typename Key, typename T, typename Compare, typename Alloc>
inline QDebug operator<<(QDebug debug, const std::map<Key, T, Compare, Alloc> &map)
{
    return QtPrivate::printSequentialContainer(debug, "std::map", map); 
}

template <typename Key, typename T, typename Compare, typename Alloc>
inline QDebug operator<<(QDebug debug, const std::multimap<Key, T, Compare, Alloc> &map)
{
    return QtPrivate::printSequentialContainer(debug, "std::multimap", map); 
}

template <class Key, class T>
inline QDebug operator<<(QDebug debug, const QMap<Key, T> &map)
{
    const bool oldSetting = debug.autoInsertSpaces();
    debug.nospace() << "QMap(";
    for (typename QMap<Key, T>::const_iterator it = map.constBegin();
         it != map.constEnd(); ++it) {
        debug << '(' << it.key() << ", " << it.value() << ')';
    }
    debug << ')';
    debug.setAutoInsertSpaces(oldSetting);
    return debug.maybeSpace();
}

template <class Key, class T>
inline QDebug operator<<(QDebug debug, const QHash<Key, T> &hash)
{
    const bool oldSetting = debug.autoInsertSpaces();
    debug.nospace() << "QHash(";
    for (typename QHash<Key, T>::const_iterator it = hash.constBegin();
            it != hash.constEnd(); ++it)
        debug << '(' << it.key() << ", " << it.value() << ')';
    debug << ')';
    debug.setAutoInsertSpaces(oldSetting);
    return debug.maybeSpace();
}

template <class T1, class T2>
inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair)
{
    const bool oldSetting = debug.autoInsertSpaces();
    debug.nospace() << "QPair(" << pair.first << ',' << pair.second << ')';
    debug.setAutoInsertSpaces(oldSetting);
    return debug.maybeSpace();
}

template <class T1, class T2>
inline QDebug operator<<(QDebug debug, const std::pair<T1, T2> &pair)
{
    const bool oldSetting = debug.autoInsertSpaces();
    debug.nospace() << "std::pair(" << pair.first << ',' << pair.second << ')';
    debug.setAutoInsertSpaces(oldSetting);
    return debug.maybeSpace();
}

template <typename T>
inline QDebug operator<<(QDebug debug, const QSet<T> &set)
{
    return QtPrivate::printSequentialContainer(debug, "QSet", set);
}

template <class T>
inline QDebug operator<<(QDebug debug, const QContiguousCache<T> &cache)
{
    const bool oldSetting = debug.autoInsertSpaces();
    debug.nospace() << "QContiguousCache(";
    for (int i = cache.firstIndex(); i <= cache.lastIndex(); ++i) {
        debug << cache[i];
        if (i != cache.lastIndex())
            debug << ", ";
    }
    debug << ')';
    debug.setAutoInsertSpaces(oldSetting);
    return debug.maybeSpace();
}

template <class T>
inline QDebug operator<<(QDebug debug, const QSharedPointer<T> &ptr)
{
    QDebugStateSaver saver(debug);
    debug.nospace() << "QSharedPointer(" << ptr.data() << ")";
    return debug;
}

__declspec(dllimport) void qt_QMetaEnum_flagDebugOperator(QDebug &debug, size_t sizeofT, int value);

template <typename Int>
void qt_QMetaEnum_flagDebugOperator(QDebug &debug, size_t sizeofT, Int value)
{
    const QDebugStateSaver saver(debug);
    debug.resetFormat();
    debug.nospace() << "QFlags(" << Qt::hex << Qt::showbase;
    bool needSeparator = false;
    for (uint i = 0; i < sizeofT * 8; ++i) {
        if (value & (Int(1) << i)) {
            if (needSeparator)
                debug << '|';
            else
                needSeparator = true;
            debug << (Int(1) << i);
        }
    }
    debug << ')';
}


__declspec(dllimport) QDebug qt_QMetaEnum_debugOperator(QDebug&, int value, const QMetaObject *meta, const char *name);
__declspec(dllimport) QDebug qt_QMetaEnum_flagDebugOperator(QDebug &dbg, quint64 value, const QMetaObject *meta, const char *name);

template<typename T>
typename std::enable_if<QtPrivate::IsQEnumHelper<T>::Value, QDebug>::type
operator<<(QDebug dbg, T value)
{
    const QMetaObject *obj = qt_getEnumMetaObject(value);
    const char *name = qt_getEnumName(value);
    return qt_QMetaEnum_debugOperator(dbg, typename QFlags<T>::Int(value), obj, name);
}

template<typename T,
         typename A = typename std::enable_if<std::is_enum<T>::value, void>::type,
         typename B = typename std::enable_if<sizeof(T) <= sizeof(int), void>::type,
         typename C = typename std::enable_if<!QtPrivate::IsQEnumHelper<T>::Value, void>::type,
         typename D = typename std::enable_if<QtPrivate::IsQEnumHelper<QFlags<T>>::Value, void>::type>
inline QDebug operator<<(QDebug dbg, T value)
{
    typedef QFlags<T> FlagsT;
    const QMetaObject *obj = qt_getEnumMetaObject(FlagsT());
    const char *name = qt_getEnumName(FlagsT());
    return qt_QMetaEnum_debugOperator(dbg, typename FlagsT::Int(value), obj, name);
}

template <class T>
inline typename std::enable_if<
    QtPrivate::IsQEnumHelper<T>::Value || QtPrivate::IsQEnumHelper<QFlags<T> >::Value,
    QDebug>::type
qt_QMetaEnum_flagDebugOperator_helper(QDebug debug, const QFlags<T> &flags)
{
    const QMetaObject *obj = qt_getEnumMetaObject(T());
    const char *name = qt_getEnumName(T());
    return qt_QMetaEnum_flagDebugOperator(debug, quint64(flags), obj, name);
}

template <class T>
inline typename std::enable_if<
    !QtPrivate::IsQEnumHelper<T>::Value && !QtPrivate::IsQEnumHelper<QFlags<T> >::Value,
    QDebug>::type
qt_QMetaEnum_flagDebugOperator_helper(QDebug debug, const QFlags<T> &flags)



#line 414 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
{
    qt_QMetaEnum_flagDebugOperator(debug, sizeof(T), typename QFlags<T>::Int(flags));
    return debug;
}

template<typename T>
inline QDebug operator<<(QDebug debug, const QFlags<T> &flags)
{
    
    
    return qt_QMetaEnum_flagDebugOperator_helper(debug, flags);
}















































































#line 506 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qdebug.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QDebug"
#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QHash"

#pragma external_header(pop)
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QMap"

#pragma external_header(pop)
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QStringList"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qstringlist.h"






























































































































































































































































































































































































































#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QStringList"
#pragma external_header(pop)
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QTimeZone"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"















































static_assert(bool(1 == 1), "Required feature " "timezone" " for file " "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h" " not available.");




#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"



class QTimeZonePrivate;

class __declspec(dllimport) QTimeZone
{
public:
    
    enum {
        
        MinUtcOffsetSecs = -14 * 3600,
        
        MaxUtcOffsetSecs = +14 * 3600
    };

    enum TimeType {
        StandardTime = 0,
        DaylightTime = 1,
        GenericTime = 2
    };

    enum NameType {
        DefaultName = 0,
        LongName = 1,
        ShortName = 2,
        OffsetName = 3
    };

    struct OffsetData {
        QString abbreviation;
        QDateTime atUtc;
        int offsetFromUtc;
        int standardTimeOffset;
        int daylightTimeOffset;
    };
    typedef QVector<OffsetData> OffsetDataList;

    QTimeZone() noexcept;
    explicit QTimeZone(const QByteArray &ianaId);
    explicit QTimeZone(int offsetSeconds);
     QTimeZone(const QByteArray &zoneId, int offsetSeconds, const QString &name,
              const QString &abbreviation, QLocale::Country country = QLocale::AnyCountry,
              const QString &comment = QString());
    QTimeZone(const QTimeZone &other);
    ~QTimeZone();

    QTimeZone &operator=(const QTimeZone &other);
    QTimeZone &operator=(QTimeZone &&other) noexcept { swap(other); return *this; }

    void swap(QTimeZone &other) noexcept
    { d.swap(other.d); }

    bool operator==(const QTimeZone &other) const;
    bool operator!=(const QTimeZone &other) const;

    bool isValid() const;

    QByteArray id() const;
    QLocale::Country country() const;
    QString comment() const;

    QString displayName(const QDateTime &atDateTime,
                        QTimeZone::NameType nameType = QTimeZone::DefaultName,
                        const QLocale &locale = QLocale()) const;
    QString displayName(QTimeZone::TimeType timeType,
                        QTimeZone::NameType nameType = QTimeZone::DefaultName,
                        const QLocale &locale = QLocale()) const;
    QString abbreviation(const QDateTime &atDateTime) const;

    int offsetFromUtc(const QDateTime &atDateTime) const;
    int standardTimeOffset(const QDateTime &atDateTime) const;
    int daylightTimeOffset(const QDateTime &atDateTime) const;

    bool hasDaylightTime() const;
    bool isDaylightTime(const QDateTime &atDateTime) const;

    OffsetData offsetData(const QDateTime &forDateTime) const;

    bool hasTransitions() const;
    OffsetData nextTransition(const QDateTime &afterDateTime) const;
    OffsetData previousTransition(const QDateTime &beforeDateTime) const;
    OffsetDataList transitions(const QDateTime &fromDateTime, const QDateTime &toDateTime) const;

    static QByteArray systemTimeZoneId();
    static QTimeZone systemTimeZone();
    static QTimeZone utc();

    static bool isTimeZoneIdAvailable(const QByteArray &ianaId);

    static QList<QByteArray> availableTimeZoneIds();
    static QList<QByteArray> availableTimeZoneIds(QLocale::Country country);
    static QList<QByteArray> availableTimeZoneIds(int offsetSeconds);

    static QByteArray ianaIdToWindowsId(const QByteArray &ianaId);
    static QByteArray windowsIdToDefaultIanaId(const QByteArray &windowsId);
    static QByteArray windowsIdToDefaultIanaId(const QByteArray &windowsId,
                                                QLocale::Country country);
    static QList<QByteArray> windowsIdToIanaIds(const QByteArray &windowsId);
    static QList<QByteArray> windowsIdToIanaIds(const QByteArray &windowsId,
                                                 QLocale::Country country);






#line 162 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"

private:
    QTimeZone(QTimeZonePrivate &dd);

    friend __declspec(dllimport) QDataStream &operator<<(QDataStream &ds, const QTimeZone &tz);
#line 168 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"
    friend class QTimeZonePrivate;
    friend class QDateTime;
    friend class QDateTimePrivate;
    QSharedDataPointer<QTimeZonePrivate> d;
};

template<> class QTypeInfo<QTimeZone::OffsetData > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QTimeZone::OffsetData>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QTimeZone::OffsetData>(), isLarge = (sizeof(QTimeZone::OffsetData)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QTimeZone::OffsetData >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QTimeZone::OffsetData) }; static inline const char *name() { return "QTimeZone::OffsetData"; } };
template<> class QTypeInfo<QTimeZone > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QTimeZone>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QTimeZone>(), isLarge = (sizeof(QTimeZone)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QTimeZone >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QTimeZone) }; static inline const char *name() { return "QTimeZone"; } }; inline void swap(QTimeZone &value1, QTimeZone &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }


__declspec(dllimport) QDataStream &operator<<(QDataStream &ds, const QTimeZone &tz);
__declspec(dllimport) QDataStream &operator>>(QDataStream &ds, QTimeZone &tz);
#line 181 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"


__declspec(dllimport) QDebug operator<<(QDebug dbg, const QTimeZone &tz);
#line 185 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"



#line 189 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimezone.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QTimeZone"
#pragma external_header(pop)
#line 13 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QTimer"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"














































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasictimer.h"
















































class QObject;

class __declspec(dllimport) QBasicTimer
{
    int id;


#line 57 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasictimer.h"






#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasictimer.h"

public:
    constexpr QBasicTimer() noexcept : id{0} {}
    inline ~QBasicTimer() { if (id) stop(); }

    QBasicTimer(QBasicTimer &&other) noexcept
        : id{qExchange(other.id, 0)}
    {}

    QBasicTimer& operator=(QBasicTimer &&other) noexcept
    {
        QBasicTimer{std::move(other)}.swap(*this);
        return *this;
    }

    void swap(QBasicTimer &other) noexcept { qSwap(id, other.id); }

    bool isActive() const noexcept { return id != 0; }
    int timerId() const noexcept { return id; }

    void start(int msec, QObject *obj);
    void start(int msec, Qt::TimerType timerType, QObject *obj);
    void stop();
};
template<> class QTypeInfo<QBasicTimer > { public: enum { isSpecialized = true, isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QBasicTimer>(), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QBasicTimer>(), isLarge = (sizeof(QBasicTimer)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QBasicTimer >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QBasicTimer) }; static inline const char *name() { return "QBasicTimer"; } };

inline void swap(QBasicTimer &lhs, QBasicTimer &rhs) noexcept { lhs.swap(rhs); }



#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore/qbasictimer.h"
#pragma external_header(pop)
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"




#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"




class __declspec(dllimport) QTimer : public QObject
{
    public: __pragma(warning(push))  static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); virtual int qt_metacall(QMetaObject::Call, int, void **); static inline QString tr(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } __declspec(deprecated) static inline QString trUtf8(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } private:   static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); __pragma(warning(pop)) struct QPrivateSignal {}; 
    
    
    
    
    
public:
    explicit QTimer(QObject *parent = nullptr);
    ~QTimer();

    inline bool isActive() const { return id >= 0; }
    int timerId() const { return id; }

    void setInterval(int msec);
    int interval() const { return inter; }

    int remainingTime() const;

    void setTimerType(Qt::TimerType atype) { this->type = atype; }
    Qt::TimerType timerType() const { return Qt::TimerType(type); }

    inline void setSingleShot(bool singleShot);
    inline bool isSingleShot() const { return single; }

    static void singleShot(int msec, const QObject *receiver, const char *member);
    static void singleShot(int msec, Qt::TimerType timerType, const QObject *receiver, const char *member);





















    
    template <typename Duration, typename Func1>
    static inline void singleShot(Duration interval, const typename QtPrivate::FunctionPointer<Func1>::Object *receiver, Func1 slot)
    {
        singleShot(interval, defaultTypeFor(interval), receiver, slot);
    }
    template <typename Duration, typename Func1>
    static inline void singleShot(Duration interval, Qt::TimerType timerType, const typename QtPrivate::FunctionPointer<Func1>::Object *receiver,
                                  Func1 slot)
    {
        typedef QtPrivate::FunctionPointer<Func1> SlotType;

        
        static_assert(bool(int(SlotType::ArgumentCount) == 0), "The slot must not have any arguments.");
#line 121 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"

        singleShotImpl(interval, timerType, receiver,
                       new QtPrivate::QSlotObject<Func1, typename SlotType::Arguments, void>(slot));
    }
    
    template <typename Duration, typename Func1>
    static inline typename std::enable_if<!QtPrivate::FunctionPointer<Func1>::IsPointerToMemberFunction &&
                                          !std::is_same<const char*, Func1>::value, void>::type
            singleShot(Duration interval, Func1 slot)
    {
        singleShot(interval, defaultTypeFor(interval), nullptr, std::move(slot));
    }
    template <typename Duration, typename Func1>
    static inline typename std::enable_if<!QtPrivate::FunctionPointer<Func1>::IsPointerToMemberFunction &&
                                          !std::is_same<const char*, Func1>::value, void>::type
            singleShot(Duration interval, Qt::TimerType timerType, Func1 slot)
    {
        singleShot(interval, timerType, nullptr, std::move(slot));
    }
    
    template <typename Duration, typename Func1>
    static inline typename std::enable_if<!QtPrivate::FunctionPointer<Func1>::IsPointerToMemberFunction &&
                                          !std::is_same<const char*, Func1>::value, void>::type
            singleShot(Duration interval, const QObject *context, Func1 slot)
    {
        singleShot(interval, defaultTypeFor(interval), context, std::move(slot));
    }
    template <typename Duration, typename Func1>
    static inline typename std::enable_if<!QtPrivate::FunctionPointer<Func1>::IsPointerToMemberFunction &&
                                          !std::is_same<const char*, Func1>::value, void>::type
            singleShot(Duration interval, Qt::TimerType timerType, const QObject *context, Func1 slot)
    {
        
        typedef QtPrivate::FunctionPointer<Func1> SlotType;
        static_assert(bool(int(SlotType::ArgumentCount) <= 0), "The slot must not have any arguments.");

        singleShotImpl(interval, timerType, context,
                       new QtPrivate::QFunctorSlotObject<Func1, 0,
                            typename QtPrivate::List_Left<void, 0>::Value, void>(std::move(slot)));
    }

    template <typename ... Args>
    QMetaObject::Connection callOnTimeout(Args && ...args)
    {
        return QObject::connect(this, &QTimer::timeout, std::forward<Args>(args)... );
    }

#line 169 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"

public :
    void start(int msec);

    void start();
    void stop();

public :
    void timeout(QPrivateSignal);

public:

    void setInterval(std::chrono::milliseconds value)
    {
        setInterval(int(value.count()));
    }

    std::chrono::milliseconds intervalAsDuration() const
    {
        return std::chrono::milliseconds(interval());
    }

    std::chrono::milliseconds remainingTimeAsDuration() const
    {
        return std::chrono::milliseconds(remainingTime());
    }

    static void singleShot(std::chrono::milliseconds value, const QObject *receiver, const char *member)
    {
        singleShot(int(value.count()), receiver, member);
    }

    static void singleShot(std::chrono::milliseconds value, Qt::TimerType timerType, const QObject *receiver, const char *member)
    {
        singleShot(int(value.count()), timerType, receiver, member);
    }

    void start(std::chrono::milliseconds value)
    {
        start(int(value.count()));
    }
#line 211 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"

protected:
    void timerEvent(QTimerEvent *) override;

private:
    QTimer(const QTimer &) = delete; QTimer &operator=(const QTimer &) = delete;

    inline int startTimer(int){ return -1;}
    inline void killTimer(int){}

    static constexpr Qt::TimerType defaultTypeFor(int msecs) noexcept
    { return msecs >= 2000 ? Qt::CoarseTimer : Qt::PreciseTimer; }
    static void singleShotImpl(int msec, Qt::TimerType timerType,
                               const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj);


    static Qt::TimerType defaultTypeFor(std::chrono::milliseconds interval)
    { return defaultTypeFor(int(interval.count())); }

    static void singleShotImpl(std::chrono::milliseconds interval, Qt::TimerType timerType,
                               const QObject *receiver, QtPrivate::QSlotObjectBase *slotObj)
    {
        singleShotImpl(int(interval.count()),
                       timerType, receiver, slotObj);
    }
#line 237 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"

    int id, inter, del;
    uint single : 1;
    uint nulltimer : 1;
    uint type : 2;
    
};

inline void QTimer::setSingleShot(bool asingleShot) { single = asingleShot; }



#line 250 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"

#line 252 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qtimer.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QTimer"
#pragma external_header(pop)
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 15 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVector"

#pragma external_header(pop)
#line 16 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

struct _Iterator_base12_compatible { 
    _Container_proxy* _Myproxy{};
    _Iterator_base12* _Mynextiter{};
};
#line 27 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

template <class _Ty, size_t _Size>
class _Array_const_iterator

    : private _Iterator_base12_compatible
#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"
{
public:

    using iterator_concept = contiguous_iterator_tag;
#line 38 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 }; 



















































































#line 129 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"
    constexpr _Array_const_iterator() noexcept : _Ptr(), _Idx(0) {}

    constexpr explicit _Array_const_iterator(pointer _Parg, size_t _Off = 0) noexcept : _Ptr(_Parg), _Idx(_Off) {}

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return *operator->();
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 138, 0, "%s", "cannot dereference value-initialized array iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized array iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 138, 0); } while (false); } ; } while (false);
        do { if (_Idx < _Size) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 139, 0, "%s", "cannot dereference out of range array iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference out of range array iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 139, 0); } while (false); } ; } while (false);
        return _Ptr + _Idx;
    }

    constexpr _Array_const_iterator& operator++() noexcept {
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 144, 0, "%s", "cannot increment value-initialized array iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized array iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 144, 0); } while (false); } ; } while (false);
        do { if (_Idx < _Size) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 145, 0, "%s", "cannot increment array iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment array iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 145, 0); } while (false); } ; } while (false);
        ++_Idx;
        return *this;
    }

    constexpr _Array_const_iterator operator++(int) noexcept {
        _Array_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr _Array_const_iterator& operator--() noexcept {
        do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 157, 0, "%s", "cannot decrement value-initialized array iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized array iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 157, 0); } while (false); } ; } while (false);
        do { if (_Idx != 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 158, 0, "%s", "cannot decrement array iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement array iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 158, 0); } while (false); } ; } while (false);
        --_Idx;
        return *this;
    }

    constexpr _Array_const_iterator operator--(int) noexcept {
        _Array_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    constexpr void _Verify_offset(const ptrdiff_t _Off) const noexcept {
        if (_Off != 0) {
            do { if (_Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 171, 0, "%s", "cannot seek value-initialized array iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized array iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 171, 0); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Idx >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 175, 0, "%s", "cannot seek array iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek array iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 175, 0); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            do { if (_Size - _Idx >= static_cast<size_t>(_Off)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 179, 0, "%s", "cannot seek array iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek array iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 179, 0); } while (false); } ; } while (false);
        }
    }

    constexpr _Array_const_iterator& operator+=(const ptrdiff_t _Off) noexcept {
        _Verify_offset(_Off);
        _Idx += static_cast<size_t>(_Off);
        return *this;
    }

    constexpr _Array_const_iterator& operator-=(const ptrdiff_t _Off) noexcept {
        return *this += -_Off;
    }

    [[nodiscard]] constexpr ptrdiff_t operator-(const _Array_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return static_cast<ptrdiff_t>(_Idx - _Right._Idx);
    }

    [[nodiscard]] constexpr reference operator[](const ptrdiff_t _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const _Array_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Idx == _Right._Idx;
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _Array_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Idx <=> _Right._Idx;
    }





#line 218 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

    constexpr void _Compat(const _Array_const_iterator& _Right) const noexcept { 
        do { if (_Ptr == _Right._Ptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 220, 0, "%s", "array iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 220, 0); } while (false); } ; } while (false);
    }

    using _Prevent_inheriting_unwrap = _Array_const_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {
        return _Ptr + _Idx;
    }

    constexpr void _Verify_with(const _Array_const_iterator& _Last) const noexcept {
        
        do { if (*this <= _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 231, 0, "%s", "array iterator range transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array iterator range transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 231, 0); } while (false); } ; } while (false);
    }

    constexpr void _Seek_to(pointer _It) noexcept {
        _Idx = static_cast<size_t>(_It - _Ptr);
    }

private:
    pointer _Ptr; 
    size_t _Idx; 
#line 242 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

public:
    [[nodiscard]] constexpr _Array_const_iterator operator+(const ptrdiff_t _Off) const noexcept {
        _Array_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr _Array_const_iterator operator-(const ptrdiff_t _Off) const noexcept {
        _Array_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] friend constexpr _Array_const_iterator operator+(
        const ptrdiff_t _Off, _Array_const_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

















#line 279 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"
};


template <class _Ty, size_t _Size>
constexpr void _Verify_range(
    const _Array_const_iterator<_Ty, _Size>& _First, const _Array_const_iterator<_Ty, _Size>& _Last) noexcept {
    
    _First._Verify_with(_Last);
}
#line 289 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"


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 302 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 311 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend constexpr _Array_iterator operator+(const ptrdiff_t _Off, _Array_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    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>
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 405 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

 template <class _Ty, size_t _Size>
class array { 
public:
    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
                                    "because of [container.requirements].");

    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 431 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "There's no way to clear an array as its size is fixed.")]] 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  {

        do { if (_Pos < _Size) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 534, 0, "%s", "array subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 534, 0); } while (false); } ; } while (false);
#line 536 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return _Elems[_Pos];
    }

    [[nodiscard]] constexpr const_reference operator[](  size_type _Pos) const noexcept
     {

        do { if (_Pos < _Size) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 543, 0, "%s", "array subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 543, 0); } while (false); } ; } while (false);
#line 545 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    _Ty _Elems[_Size];

private:
    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid array<T, N> subscript");
    }
};


template <class _First, class... _Rest>
struct _Enforce_same {
    static_assert(
        conjunction_v<is_same<_First, _Rest>...>, "N4950 [array.cons]/2: Mandates: (is_same_v<T, U> && ...) is true.");
    using type = _First;
};

template <class _First, class... _Rest>
array(_First, _Rest...) -> array<typename _Enforce_same<_First, _Rest...>::type, 1 + sizeof...(_Rest)>;
#line 592 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

struct _Empty_array_element {};

template <class _Ty>
class array<_Ty, 0> {
public:
    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
                                    "because of [container.requirements].");

    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 617 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "There's no way to clear an array as its size is fixed.")]] 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  {

        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 708, 0, "%s", "array subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 708, 0); } while (false);
#line 710 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return *data();
    }

    [[nodiscard]] const_reference operator[](size_type) const noexcept  {

        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 716, 0, "%s", "array subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 716, 0); } while (false);
#line 718 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return *data();
    }

    [[nodiscard]] reference front() noexcept  {

        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 724, 0, "%s", "array<T, 0>::front() invalid")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array<T, 0>::front() invalid\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 724, 0); } while (false);
#line 726 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return *data();
    }

    [[nodiscard]] const_reference front() const noexcept  {

        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 732, 0, "%s", "array<T, 0>::front() invalid")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array<T, 0>::front() invalid\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 732, 0); } while (false);
#line 734 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return *data();
    }

    [[nodiscard]] reference back() noexcept  {

        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 740, 0, "%s", "array<T, 0>::back() invalid")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array<T, 0>::back() invalid\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 740, 0); } while (false);
#line 742 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return *data();
    }

    [[nodiscard]] const_reference back() const noexcept  {

        do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 748, 0, "%s", "array<T, 0>::back() invalid")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"array<T, 0>::back() invalid\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array", 748, 0); } while (false);
#line 750 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"

        return *data();
    }

    [[nodiscard]] constexpr _Ty* data() noexcept {
        return nullptr;
    }

    [[nodiscard]] constexpr const _Ty* data() const noexcept {
        return nullptr;
    }

    conditional_t<disjunction_v<is_default_constructible<_Ty>, _Is_implicitly_default_constructible<_Ty>>, _Ty,
        _Empty_array_element>
        _Elems[1]{};

private:
    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid array<T, 0> subscript");
    }
};

 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))) {
    _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 788 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 818 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>, "N4950 [array.creation]/1: "
                                    "to_array does not accept multidimensional arrays.");
    static_assert(is_constructible_v<_Ty, _Ty&>, "N4950 [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>, "N4950 [array.creation]/4: "
                                    "to_array does not accept multidimensional arrays.");
    static_assert(is_move_constructible_v<_Ty>, "N4950 [array.creation]/4: "
                                                "to_array requires move constructible elements.");
    return _To_array_rvalue_impl(::std:: move(_Array), make_index_sequence<_Size>{});
}
#line 850 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 881 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"
}



#pragma warning(pop)
#pragma pack(pop)
#line 888 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"
#line 889 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\array"
#pragma external_header(pop)
#line 19 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"





#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 <size_t _Bits>
class bitset { 
private:
#pragma warning(push)
#pragma warning(disable : 4296) 
    using _Ty = conditional_t<_Bits <= sizeof(unsigned long) * 8, unsigned long, unsigned long long>;
#pragma warning(pop)

public:
    class reference { 
        friend bitset;

    public:
        inline reference(const reference&) = default;

        inline ~reference() noexcept {} 

        inline reference& operator=(const bool _Val) noexcept {
            _Pbitset->_Set_unchecked(_Mypos, _Val);
            return *this;
        }

        inline reference& operator=(const reference& _Bitref) noexcept {
            _Pbitset->_Set_unchecked(_Mypos, static_cast<bool>(_Bitref));
            return *this;
        }

        [[nodiscard]] inline bool operator~() const noexcept {
            return !_Pbitset->_Subscript(_Mypos);
        }

        inline operator bool() const noexcept {
            return _Pbitset->_Subscript(_Mypos);
        }

        inline reference& flip() noexcept {
            _Pbitset->_Flip_unchecked(_Mypos);
            return *this;
        }

    private:
        inline reference() noexcept : _Pbitset(nullptr), _Mypos(0) {}

        inline reference(bitset<_Bits>& _Bitset, const size_t _Pos) noexcept : _Pbitset(&_Bitset), _Mypos(_Pos) {}

        bitset<_Bits>* _Pbitset;
        size_t _Mypos; 
    };

private:
    static constexpr void _Validate(const size_t _Pos) noexcept { 


#line 77 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
        do { if (_Pos < _Bits) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset", 77, 0, "%s", "bitset index outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"bitset index outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset", 77, 0); } while (false); } ; } while (false);
#line 79 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
    }

    constexpr bool _Subscript(size_t _Pos) const noexcept {
        return (_Array[_Pos / _Bitsperword] & (_Ty{1} << _Pos % _Bitsperword)) != 0;
    }

    static constexpr bool _Need_mask          = _Bits < 8 * sizeof(unsigned long long);
    static constexpr unsigned long long _Mask = (1ULL << (_Need_mask ? _Bits : 0)) - 1ULL;

public:
    [[nodiscard]] constexpr bool operator[](size_t _Pos) const noexcept  {
        _Validate(_Pos);
        return _Subscript(_Pos);
    }

    [[nodiscard]] inline reference operator[](const size_t _Pos) noexcept  {
        _Validate(_Pos);
        return reference(*this, _Pos);
    }

    constexpr bitset() noexcept : _Array() {} 

    constexpr bitset(unsigned long long _Val) noexcept : _Array{static_cast<_Ty>(_Need_mask ? _Val & _Mask : _Val)} {}

private:
    template <class _Traits, class _Elem>
    inline 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;
        }
    }

public:
    template <class _Elem, class _Traits, class _Alloc>
    inline 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>
    inline 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);
    }

    inline bitset& operator&=(const bitset& _Right) noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] &= _Right._Array[_Wpos];
        }

        return *this;
    }

    inline bitset& operator|=(const bitset& _Right) noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] |= _Right._Array[_Wpos];
        }

        return *this;
    }

    inline bitset& operator^=(const bitset& _Right) noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] ^= _Right._Array[_Wpos];
        }

        return *this;
    }

    inline 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;
    }

    inline 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;
    }

    inline bitset& set() noexcept { 






#line 247 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
        {
            :: memset(&_Array, 0xFF, sizeof(_Array));
        }
        _Trim();
        return *this;
    }

    inline bitset& set(const size_t _Pos, bool _Val = true) { 
        if (_Bits <= _Pos) {
            _Xran(); 
        }

        return _Set_unchecked(_Pos, _Val);
    }

    inline bitset& reset() noexcept { 






#line 270 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
        {
            :: memset(&_Array, 0, sizeof(_Array));
        }
        return *this;
    }

    inline bitset& reset(const size_t _Pos) { 
        return set(_Pos, false);
    }

    [[nodiscard]] inline bitset operator~() const noexcept { 
        bitset _Tmp = *this;
        _Tmp.flip();
        return _Tmp;
    }

    inline bitset& flip() noexcept { 
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] = ~_Array[_Wpos];
        }

        _Trim();
        return *this;
    }

    inline bitset& flip(const size_t _Pos) { 
        if (_Bits <= _Pos) {
            _Xran(); 
        }

        return _Flip_unchecked(_Pos);
    }

    [[nodiscard]] inline unsigned long to_ulong() const noexcept(_Bits <= 32)  {
        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]] inline unsigned long long to_ullong() const noexcept(_Bits <= 64)  {
        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]] inline basic_string<_Elem, _Tr, _Alloc> to_string(
        const _Elem _Elem0 = static_cast<_Elem>('0'), const _Elem _Elem1 = static_cast<_Elem>('1')) const {
        
        basic_string<_Elem, _Tr, _Alloc> _Str(_Bits, _Elem0);
        for (size_t _Pos = 0; _Pos < _Bits; ++_Pos) {
            if (_Subscript(_Bits - 1 - _Pos)) {
                _Str[_Pos] = _Elem1;
            }
        }

        return _Str;
    }

    [[nodiscard]] inline 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]] inline bool operator==(const bitset& _Right) const noexcept {









#line 386 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
        {
            return :: memcmp(&_Array[0], &_Right._Array[0], sizeof(_Array)) == 0;
        }
    }





#line 396 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"

    [[nodiscard]] inline bool test(const size_t _Pos) const {
        if (_Bits <= _Pos) {
            _Xran(); 
        }

        return _Subscript(_Pos);
    }

    [[nodiscard]] inline bool any() const noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            if (_Array[_Wpos] != 0) {
                return true;
            }
        }

        return false;
    }

    [[nodiscard]] inline bool none() const noexcept {
        return !any();
    }

    [[nodiscard]] inline 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]] inline bitset operator<<(const size_t _Pos) const noexcept {
        bitset _Tmp = *this;
        _Tmp <<= _Pos;
        return _Tmp;
    }

    [[nodiscard]] inline bitset operator>>(const 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; 

    inline 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;
        }
    }

    inline bitset& _Set_unchecked(const size_t _Pos, const 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;
    }

    inline bitset& _Flip_unchecked(const size_t _Pos) noexcept { 
        _Array[_Pos / _Bitsperword] ^= _Ty{1} << _Pos % _Bitsperword;
        return *this;
    }

    [[noreturn]] static void _Xinv() {
        _Xinvalid_argument("invalid bitset char");
    }

    [[noreturn]] static void _Xoflo() {
        _Xoverflow_error("bitset overflow");
    }

    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid bitset position");
    }

    _Ty _Array[_Words + 1];
};

 template <size_t _Bits>
[[nodiscard]] inline 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]] inline 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]] inline 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>> {
    using _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 suppress this warning.")]] = bitset<_Bits>;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[nodiscard]] size_t operator()(const bitset<_Bits>& _Keyval) const noexcept {
        return _Hash_representation(_Keyval._Array);
    }
};
}



#pragma warning(pop)
#pragma pack(pop)
#line 591 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
#line 592 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\bitset"
#pragma external_header(pop)
#line 20 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cassert"








#pragma external_header(push)
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\assert.h"









#line 11 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.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" {





#line 24 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\assert.h"









    __declspec(dllimport) void __cdecl _wassert(
          wchar_t const* _Message,
          wchar_t const* _File,
            unsigned       _Line
        );

    




#line 45 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.22621.0\\ucrt\\assert.h"



} __pragma(pack(pop))

#pragma warning(pop) 
#pragma external_header(pop)
#line 10 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\cassert"
#pragma external_header(pop)
#line 21 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"





#pragma once










#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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" {





 double __cdecl _Cosh(double, double);
 double __cdecl _Sinh(double, double);
 short __cdecl _Exp(double*, double, short);

 float __cdecl _FCosh(float, float);
 float __cdecl _FSinh(float, float);
 short __cdecl _FExp(float*, float, short);

 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);

}



#pragma warning(pop)
#pragma pack(pop)
#line 44 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ymath.h"
#line 45 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\ymath.h"
#pragma external_header(pop)
#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"







#line 26 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"

#line 28 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"



extern "C" __m128d __cdecl _mm_fmsub_sd(__m128d, __m128d, __m128d);
#line 33 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 >= _Stl_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 186 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"





#line 192 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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{0.5};
            constexpr _Ty _Norm_big{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 537 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"
        const auto _Uint = _Bit_cast<uint64_t>(_Left);
        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
#line 540 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"
    }

    static constexpr bool _Isnan(_Ty _Left) {


#line 546 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"
        const auto _Uint = _Bit_cast<uint64_t>(_Left);
        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
#line 549 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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] /= _Rightreal;
            this->_Val[1] /= _Rightreal;
        } 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>>;

    [[deprecated("warning STL4037: " "The effect of instantiating the template std::complex for any " "type other than float, double, or long double is unspecified. " "You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to " "suppress this warning.")]]
    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>
    [[deprecated("warning STL4037: " "The effect of instantiating the template std::complex for any " "type other than float, double, or long double is unspecified. " "You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to " "suppress this warning.")]] 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 += _Right;
    return _Tmp;
}

 template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator+(const _Ty& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Right);
    _Tmp += _Left;
    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 -= _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 *= _Right;
    return _Tmp;
}

 template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator*(const _Ty& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Right);
    _Tmp *= _Left;
    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 /= _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 1513 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_val = 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_val; 
            } else {
                _Ux = static_cast<_Ty>(0.25) * _Pi_val; 
            }
        } else if (_Re < 0) {
            _Ux = _Pi_val; 
        } else {
            _Ux = 0; 
        }
        _Vx = -_Ctraits<_Ty>::_Copysign(_Ctraits<_Ty>::_Infv(), _Im);
    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { 
        _Ux = static_cast<_Ty>(0.50) * _Pi_val; 
        _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_val = 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_val; 
            } else {
                _Vx = static_cast<_Ty>(0.25) * _Pi_val; 
            }
        } else if (_Re < 0) {
            _Vx = _Pi_val; 
        } 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_val, _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_val = 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_val, _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_val, _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 = _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 2268 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"
#line 2269 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\complex"
#pragma external_header(pop)
#line 24 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\condition_variable"





#pragma once










#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\condition_variable"
        const auto _Now                  = _Clock::now();
        using _Common_duration           = decltype(_Abs_time - _Now);
        const _Common_duration _Rel_time = (_Abs_time <= _Now) ? _Common_duration::zero() : _Abs_time - _Now;
        return wait_for(_Lck, _Rel_time);
    }

    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 110 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
        }

        
        
        _timespec64 _Tgt;
        const bool _Clamped     = _To_timespec64_sys_10_day_clamped(_Tgt, _Rel_time);
        const cv_status _Result = _Wait_until_sys_time(_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));
    }


private:
    struct _Cv_any_notify_all {
        condition_variable_any* _This;

        explicit _Cv_any_notify_all(condition_variable_any* _This_) noexcept : _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;
            
            
            _timespec64 _Tgt;
            (void) _To_timespec64_sys_10_day_clamped(_Tgt, _Rel_time);
            (void) _Cnd_timedwait(_Mycnd(), _Myptr->_Mymtx(), &_Tgt);
            _Guard_unlocks_before_locking_outer.unlock();
        } 

        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 226 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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_sys_time(_Lock& _Lck, const _timespec64* 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();

        if (_Res == _Thrd_success) {
            return cv_status::no_timeout;
        } else {
            return cv_status::timeout;
        }
    }
};

 inline void notify_all_at_thread_exit(condition_variable& _Cnd, unique_lock<mutex> _Lck) noexcept
 {
    
    _Cnd._Register(_Lck, nullptr);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 264 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\condition_variable"
#line 265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\condition_variable"
#pragma external_header(pop)
#line 25 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"











#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

    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 83 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }





















#line 137 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"

    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 207 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"
#line 208 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 221 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 263 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

    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);
    }





















#line 347 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"

    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 424 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"
#line 425 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 438 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 468 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 481 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 491 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"
}


#pragma warning(pop)
#pragma pack(pop)
#line 497 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"
#line 498 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\set"
#pragma external_header(pop)
#line 37 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 36 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (_Mybegin) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 44, 0, "%s", "cannot dereference value-initialized span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 44, 0); } while (false); } ; } while (false);
        do { if (_Myptr < _Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 45, 0, "%s", "cannot dereference end span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 45, 0); } while (false); } ; } while (false);
#line 47 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return *_Myptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {

        do { if (_Mybegin) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 52, 0, "%s", "cannot dereference value-initialized span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 52, 0); } while (false); } ; } while (false);
        do { if (_Myptr < _Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 53, 0, "%s", "cannot dereference end span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference end span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 53, 0); } while (false); } ; } while (false);
#line 55 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Myptr;
    }

    constexpr _Span_iterator& operator++() noexcept {

        do { if (_Mybegin) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 60, 0, "%s", "cannot increment value-initialized span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 60, 0); } while (false); } ; } while (false);
        do { if (_Myptr < _Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 61, 0, "%s", "cannot increment span iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment span iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 61, 0); } while (false); } ; } while (false);
#line 63 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        ++_Myptr;
        return *this;
    }

    constexpr _Span_iterator operator++(int) noexcept {
        _Span_iterator _Tmp{*this};
        ++*this;
        return _Tmp;
    }

    constexpr _Span_iterator& operator--() noexcept {

        do { if (_Mybegin) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 75, 0, "%s", "cannot decrement value-initialized span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 75, 0); } while (false); } ; } while (false);
        do { if (_Mybegin < _Myptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 76, 0, "%s", "cannot decrement span iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement span iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 76, 0); } while (false); } ; } while (false);
#line 78 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        if (_Off != 0) {
            do { if (_Mybegin) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 91, 0, "%s", "cannot seek value-initialized span iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized span iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 91, 0); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Myptr - _Mybegin >= -_Off) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 95, 0, "%s", "cannot seek span iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek span iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 95, 0); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            do { if (_Myend - _Myptr >= _Off) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 99, 0, "%s", "cannot seek span iterator after end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek span iterator after end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 99, 0); } while (false); } ; } while (false);
        }
#line 102 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
        do { if (_Off != _Min_possible_v<difference_type>) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 122, 0, "%s", "integer overflow")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"integer overflow\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 122, 0); } while (false); } ; } while (false);
        _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 {

        do { if (_Mybegin == _Right._Mybegin && _Myend == _Right._Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 137, 0, "%s", "cannot subtract incompatible span iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot subtract incompatible span iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 137, 0); } while (false); } ; } while (false);
#line 138 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 139 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        do { if (_Mybegin == _Right._Mybegin && _Myend == _Right._Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 149, 0, "%s", "cannot compare incompatible span iterators for equality")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot compare incompatible span iterators for equality\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 149, 0); } while (false); } ; } while (false);
#line 150 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 151 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Myptr == _Right._Myptr;
    }

    [[nodiscard]] constexpr strong_ordering operator<=>(const _Span_iterator& _Right) const noexcept {

        do { if (_Mybegin == _Right._Mybegin && _Myend == _Right._Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 157, 0, "%s", "cannot compare incompatible span iterators")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot compare incompatible span iterators\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 157, 0); } while (false); } ; } while (false);
#line 158 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 159 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Myptr <=> _Right._Myptr;
    }


    friend constexpr void _Verify_range(const _Span_iterator& _First, const _Span_iterator& _Last) noexcept {
        do { if (_First._Mybegin == _Last._Mybegin && _First._Myend == _Last._Myend) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 165, 0, "%s", "span iterators from different views do not form a range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"span iterators from different views do not form a range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 165, 0); } while (false); } ; } while (false);
#line 166 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        do { if (_First._Myptr <= _Last._Myptr) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 166, 0, "%s", "span iterator range transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"span iterator range transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 166, 0); } while (false); } ; } while (false);
    }
#line 169 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"

    using _Prevent_inheriting_unwrap = _Span_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {
        return _Myptr;
    }

    static constexpr bool _Unwrap_when_unverified = 2 == 0;

    constexpr void _Seek_to(const pointer _It) noexcept {
        _Myptr = _It;
    }

    pointer _Myptr   = nullptr;

    pointer _Mybegin = nullptr;
    pointer _Myend   = nullptr;
#line 187 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 _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 _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 295 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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>;



#line 319 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"

    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) {

        if constexpr (_Extent != dynamic_extent) {
            do { if (_Count == _Extent) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 334, 0, "%s", "Cannot construct span with static extent from range [first, first + count) as count != extent")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot construct span with static extent from range [first, first + count) as count != extent\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 334, 0); } while (false); } ; } while (false);
#line 335 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        }
#line 337 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);

        if constexpr (_Extent != dynamic_extent) {
            do { if (_Last - _First == _Extent) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 347, 0, "%s", "Cannot construct span with static extent from range [first, last) as last - first != extent")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot construct span with static extent from range [first, last) as last - first != extent\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 347, 0); } while (false); } ; } while (false);
#line 348 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        }
#line 350 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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))) {

        if constexpr (_Extent != dynamic_extent) {
            do { if (::std::ranges:: size(_Range) == _Extent) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 372, 0, "%s", "Cannot construct span with static extent from range r as std::ranges::size(r) != extent")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot construct span with static extent from range r as std::ranges::size(r) != extent\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 372, 0); } while (false); } ; } while (false);
#line 373 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        }
#line 375 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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()) {

        if constexpr (_Extent != dynamic_extent) {
            do { if (_Other.size() == _Extent) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 386, 0, "%s", "Cannot construct span with static extent from other span as other.size() != extent")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Cannot construct span with static extent from other span as other.size() != extent\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 386, 0); } while (false); } ; } while (false);
#line 387 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        }
#line 389 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        }
    
















































































#line 472 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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()");
        }

        else {
            do { if (_Count <= _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 481, 0, "%s", "Count out of range in span::first()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Count out of range in span::first()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 481, 0); } while (false); } ; } while (false);
        }
#line 484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return span<element_type, _Count>{_Mydata, _Count};
    }

    [[nodiscard]] constexpr auto first(const size_type _Count) const noexcept
     {

        do { if (_Count <= _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 490, 0, "%s", "Count out of range in span::first(count)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Count out of range in span::first(count)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 490, 0); } while (false); } ; } while (false);
#line 492 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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()");
        }

        else {
            do { if (_Count <= _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 502, 0, "%s", "Count out of range in span::last()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Count out of range in span::last()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 502, 0); } while (false); } ; } while (false);
        }
#line 505 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return span<element_type, _Count>{_Mydata + (_Mysize - _Count), _Count};
    }

    [[nodiscard]] constexpr auto last(const size_type _Count) const noexcept  {

        do { if (_Count <= _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 510, 0, "%s", "Count out of range in span::last(count)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Count out of range in span::last(count)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 510, 0); } while (false); } ; } while (false);
#line 512 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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()");
        }

        else {
            do { if (_Offset <= _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 524, 0, "%s", "Offset out of range in span::subspan()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Offset out of range in span::subspan()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 524, 0); } while (false); } ; } while (false);

            if constexpr (_Count != dynamic_extent) {
                do { if (_Count <= _Mysize - _Offset) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 527, 0, "%s", "Count out of range in span::subspan()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Count out of range in span::subspan()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 527, 0); } while (false); } ; } while (false);
            }
        }
#line 531 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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
     {

        do { if (_Offset <= _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 539, 0, "%s", "Offset out of range in span::subspan(offset, count)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Offset out of range in span::subspan(offset, count)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 539, 0); } while (false); } ; } while (false);
        do { if (_Count == dynamic_extent || _Count <= _Mysize - _Offset) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 541, 0, "%s", "Count out of range in span::subspan(offset, count)")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"Count out of range in span::subspan(offset, count)\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 541, 0); } while (false); } ; } while (false);
#line 542 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 543 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

#pragma warning(push)
#pragma warning(disable : 4127) 
    [[nodiscard]] constexpr size_type size_bytes() const noexcept {

        do { if (_Mysize <= dynamic_extent / sizeof(element_type)) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 557, 0, "%s", "size of span in bytes exceeds std::numeric_limits<size_t>::max()")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"size of span in bytes exceeds std::numeric_limits<size_t>::max()\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 557, 0); } while (false); } ; } while (false);
#line 558 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 559 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Mysize * sizeof(element_type);
    }
#pragma warning(pop)

    [[nodiscard]] constexpr bool empty() const noexcept {
        return _Mysize == 0;
    }

    
    [[nodiscard]] constexpr reference operator[](const size_type _Off) const noexcept  {

        do { if (_Off < _Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 570, 0, "%s", "span index out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"span index out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 570, 0); } while (false); } ; } while (false);
#line 572 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Mydata[_Off];
    }

#pragma warning(push)
#pragma warning(disable : 4127) 
    [[nodiscard]] constexpr reference front() const noexcept  {

        do { if (_Mysize > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 579, 0, "%s", "front of empty span")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front of empty span\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 579, 0); } while (false); } ; } while (false);
#line 581 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Mydata[0];
    }

    [[nodiscard]] constexpr reference back() const noexcept  {

        do { if (_Mysize > 0) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 586, 0, "%s", "back of empty span")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back of empty span\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span", 586, 0); } while (false); } ; } while (false);
#line 588 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
        return _Mydata[_Mysize - 1];
    }
#pragma warning(pop)

    [[nodiscard]] constexpr pointer data() const noexcept {
        return _Mydata;
    }

    
    [[nodiscard]] constexpr iterator begin() const noexcept {

        return {_Mydata, _Mydata, _Mydata + _Mysize};


#line 603 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
    }

    [[nodiscard]] constexpr iterator end() const noexcept {
        const auto _End = _Mydata + _Mysize;

        return {_End, _Mydata, _End};


#line 612 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
    }









#line 623 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"

    [[nodiscard]] constexpr reverse_iterator rbegin() const noexcept {
        return reverse_iterator{end()};
    }

    [[nodiscard]] constexpr reverse_iterator rend() const noexcept {
        return reverse_iterator{begin()};
    }









#line 641 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"

    [[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 677 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 692 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"

}



#pragma warning(pop)
#pragma pack(pop)
#line 700 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 701 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#line 702 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\span"
#pragma external_header(pop)
#line 38 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"




#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeindex"





#pragma once









#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {
        
        if (_Tptr == _Right._Tptr) {
            return strong_ordering::equal;
        }

        return :: strcmp(_Tptr->raw_name() + 1, _Right._Tptr->raw_name() + 1) <=> 0;
    }




#line 56 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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> {
    using _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 suppress this warning.")]] = type_index;
    using _Unnameable_result [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]   = size_t;

    [[nodiscard]] size_t operator()(const type_index& _Keyval) const noexcept {
        return _Keyval.hash_code();
    }
};
}



#pragma warning(pop)
#pragma pack(pop)
#line 93 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeindex"
#line 94 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\typeindex"
#pragma external_header(pop)
#line 43 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"


#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

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 101 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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);
    }





















































#line 243 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"

    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 379 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"
#line 380 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 394 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 408 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
                                     "because of [container.requirements].");

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) {}






















































#line 593 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"

    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 722 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"
#line 723 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 737 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 751 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"






#line 758 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 768 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"
}


#pragma warning(pop)
#pragma pack(pop)
#line 774 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"
#line 775 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\unordered_set"
#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"

#line 48 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\pch.h"
#line 6 "F:/Frank/src/vcpkg/buildtrees/tinyorm/x64-windows-dbg/CMakeFiles/TinyOrm.dir/cmake_pch.hxx"
#line 7 "F:/Frank/src/vcpkg/buildtrees/tinyorm/x64-windows-dbg/CMakeFiles/TinyOrm.dir/cmake_pch.hxx"
#pragma external_header(pop)
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"
#pragma once



#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/systemheader.hpp"
#pragma once











#line 15 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/systemheader.hpp"

#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/systemheader.hpp"
#line 18 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/systemheader.hpp"





__pragma(system_header)

#line 26 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/systemheader.hpp"
#line 6 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"
__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectionresolverinterface.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectionresolverinterface.hpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/commonnamespace.hpp"
#pragma once




__pragma(system_header)









#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/commonnamespace.hpp"

#line 19 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/commonnamespace.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectionresolverinterface.hpp"



namespace Orm
{
    class DatabaseConnection;

    
    class ConnectionResolverInterface
    {
        ConnectionResolverInterface(const ConnectionResolverInterface &) = delete; ConnectionResolverInterface &operator=(const ConnectionResolverInterface &) = delete;

    public:
        
        inline ConnectionResolverInterface() = default;
        
        inline virtual ~ConnectionResolverInterface() = 0;

        
        virtual DatabaseConnection &connection(const QString &name = "") = 0;

        
        virtual const QString &getDefaultConnection() const = 0;

        
        virtual void setDefaultConnection(const QString &defaultConnection) = 0;

        
        virtual void resetDefaultConnection() = 0;
    };

    

    ConnectionResolverInterface::~ConnectionResolverInterface() = default;

} 



#line 51 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectionresolverinterface.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/concerns/buildsqueries.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/sqlquery.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/QSqlQuery"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlquery.h"










































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsqlglobal.h"











































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsql-config.h"

#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsqlglobal.h"






#line 52 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsqlglobal.h"

#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsqlglobal.h"


#line 57 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsqlglobal.h"

namespace QSql
{
    enum Location
    {
        BeforeFirstRow = -1,
        AfterLastRow = -2
    };

    enum ParamTypeFlag
    {
        In = 0x00000001,
        Out = 0x00000002,
        InOut = In | Out,
        Binary = 0x00000004
    };
    typedef QFlags<ParamTypeFlag> ParamType;

    enum TableType
    {
        Tables = 0x01,
        SystemTables = 0x02,
        Views = 0x04,
        AllTables = 0xff
    };

    enum NumericalPrecisionPolicy
    {
        LowPrecisionInt32    = 0x01,
        LowPrecisionInt64    = 0x02,
        LowPrecisionDouble   = 0x04,

        HighPrecision        = 0
    };
}

constexpr inline QFlags<QSql::ParamType::enum_type> operator|(QSql::ParamType::enum_type f1, QSql::ParamType::enum_type f2) noexcept { return QFlags<QSql::ParamType::enum_type>(f1) | f2; } constexpr inline QFlags<QSql::ParamType::enum_type> operator|(QSql::ParamType::enum_type f1, QFlags<QSql::ParamType::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QSql::ParamType::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }



#line 98 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qtsqlglobal.h"
#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlquery.h"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qsqldatabase.h"
















































class QSqlError;
class QSqlDriver;
class QSqlIndex;
class QSqlRecord;
class QSqlQuery;
class QSqlDatabasePrivate;

class __declspec(dllimport) QSqlDriverCreatorBase
{
public:
    virtual ~QSqlDriverCreatorBase() {}
    virtual QSqlDriver *createObject() const = 0;
};

template <class T>
class QSqlDriverCreator : public QSqlDriverCreatorBase
{
public:
    QSqlDriver *createObject() const override { return new T; }
};

class __declspec(dllimport) QSqlDatabase
{
public:
    QSqlDatabase();
    QSqlDatabase(const QSqlDatabase &other);
    ~QSqlDatabase();

    QSqlDatabase &operator=(const QSqlDatabase &other);

    bool open();
    bool open(const QString& user, const QString& password);
    void close();
    bool isOpen() const;
    bool isOpenError() const;
    QStringList tables(QSql::TableType type = QSql::Tables) const;
    QSqlIndex primaryIndex(const QString& tablename) const;
    QSqlRecord record(const QString& tablename) const;
    QSqlQuery exec(const QString& query = QString()) const;
    QSqlError lastError() const;
    bool isValid() const;

    bool transaction();
    bool commit();
    bool rollback();

    void setDatabaseName(const QString& name);
    void setUserName(const QString& name);
    void setPassword(const QString& password);
    void setHostName(const QString& host);
    void setPort(int p);
    void setConnectOptions(const QString& options = QString());
    QString databaseName() const;
    QString userName() const;
    QString password() const;
    QString hostName() const;
    QString driverName() const;
    int port() const;
    QString connectOptions() const;
    QString connectionName() const;
    void setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy);
    QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const;

    QSqlDriver* driver() const;

    static const char *defaultConnection;

    static QSqlDatabase addDatabase(const QString& type,
                                 const QString& connectionName = QLatin1String(defaultConnection));
    static QSqlDatabase addDatabase(QSqlDriver* driver,
                                 const QString& connectionName = QLatin1String(defaultConnection));
    static QSqlDatabase cloneDatabase(const QSqlDatabase &other, const QString& connectionName);
    static QSqlDatabase cloneDatabase(const QString &other, const QString& connectionName);
    static QSqlDatabase database(const QString& connectionName = QLatin1String(defaultConnection),
                                 bool open = true);
    static void removeDatabase(const QString& connectionName);
    static bool contains(const QString& connectionName = QLatin1String(defaultConnection));
    static QStringList drivers();
    static QStringList connectionNames();
    static void registerSqlDriver(const QString &name, QSqlDriverCreatorBase *creator);
    static bool isDriverAvailable(const QString &name);

protected:
    explicit QSqlDatabase(const QString& type);
    explicit QSqlDatabase(QSqlDriver* driver);

private:
    friend class QSqlDatabasePrivate;
    QSqlDatabasePrivate *d;
};


__declspec(dllimport) QDebug operator<<(QDebug, const QSqlDatabase &);
#line 143 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qsqldatabase.h"



#line 147 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/qsqldatabase.h"
#pragma external_header(pop)
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlquery.h"





class QVariant;
class QSqlDriver;
class QSqlError;
class QSqlResult;
class QSqlRecord;
template <class Key, class T> class QMap;
class QSqlQueryPrivate;

class __declspec(dllimport) QSqlQuery
{
public:
    explicit QSqlQuery(QSqlResult *r);
    explicit QSqlQuery(const QString& query = QString(), QSqlDatabase db = QSqlDatabase());
    explicit QSqlQuery(QSqlDatabase db);
    QSqlQuery(const QSqlQuery& other);
    QSqlQuery& operator=(const QSqlQuery& other);
    ~QSqlQuery();

    bool isValid() const;
    bool isActive() const;
    bool isNull(int field) const;
    bool isNull(const QString &name) const;
    int at() const;
    QString lastQuery() const;
    int numRowsAffected() const;
    QSqlError lastError() const;
    bool isSelect() const;
    int size() const;
    const QSqlDriver* driver() const;
    const QSqlResult* result() const;
    bool isForwardOnly() const;
    QSqlRecord record() const;

    void setForwardOnly(bool forward);
    bool exec(const QString& query);
    QVariant value(int i) const;
    QVariant value(const QString& name) const;

    void setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy);
    QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const;

    bool seek(int i, bool relative = false);
    bool next();
    bool previous();
    bool first();
    bool last();

    void clear();

    
    bool exec();
    enum BatchExecutionMode { ValuesAsRows, ValuesAsColumns };
    bool execBatch(BatchExecutionMode mode = ValuesAsRows);
    bool prepare(const QString& query);
    void bindValue(const QString& placeholder, const QVariant& val,
                   QSql::ParamType type = QSql::In);
    void bindValue(int pos, const QVariant& val, QSql::ParamType type = QSql::In);
    void addBindValue(const QVariant& val, QSql::ParamType type = QSql::In);
    QVariant boundValue(const QString& placeholder) const;
    QVariant boundValue(int pos) const;
    QMap<QString, QVariant> boundValues() const;
    QString executedQuery() const;
    QVariant lastInsertId() const;
    void finish();
    bool nextResult();

private:
    QSqlQueryPrivate* d;
};



#line 123 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlquery.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/QSqlQuery"
#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/sqlquery.hpp"



#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export_common.hpp"
#pragma once




__pragma(system_header)











#line 21 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export_common.hpp"



#line 25 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export_common.hpp"

#line 27 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export_common.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export.hpp"





#line 15 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export.hpp"






#line 22 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/export.hpp"
#line 13 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/sqlquery.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QTimeZone"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"
#pragma once




__pragma(system_header)




#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"







#line 20 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"

#line 23 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"




#line 28 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"



#line 32 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"




#line 37 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"



#line 41 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"





#line 48 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"

#line 50 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/config.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants.hpp"


#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants_extern.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants_extern.hpp"







namespace Orm::Constants
{

    
    __declspec(dllexport) extern const QChar SPACE;
    __declspec(dllexport) extern const QChar DOT;
    __declspec(dllexport) extern const QChar SEMICOLON;
    __declspec(dllexport) extern const QChar COLON;
    __declspec(dllexport) extern const QChar UNDERSCORE;
    __declspec(dllexport) extern const QChar DASH;
    __declspec(dllexport) extern const QChar MINUS;
    __declspec(dllexport) extern const QChar PLUS;
    __declspec(dllexport) extern const QChar ASTERISK_C;
    __declspec(dllexport) extern const QChar COMMA_C;
    __declspec(dllexport) extern const QChar EQ_C;
    __declspec(dllexport) extern const QChar NOT_C;
    __declspec(dllexport) extern const QChar LT_C;
    __declspec(dllexport) extern const QChar GT_C;
    __declspec(dllexport) extern const QChar QUOTE;
    __declspec(dllexport) extern const QChar SQUOTE;

    
    __declspec(dllexport) extern const QString NEWLINE;
    __declspec(dllexport) extern const QString EMPTY;
    __declspec(dllexport) extern const QString ASTERISK;
    __declspec(dllexport) extern const QString COMMA;
    __declspec(dllexport) extern const QString INNER;
    __declspec(dllexport) extern const QString LEFT;
    __declspec(dllexport) extern const QString RIGHT;
    __declspec(dllexport) extern const QString CROSS;
    __declspec(dllexport) extern const QString ASC;
    __declspec(dllexport) extern const QString DESC;
    __declspec(dllexport) extern const QString ID;
    __declspec(dllexport) extern const QString NAME;
    __declspec(dllexport) extern const QString SIZE_; 
    __declspec(dllexport) extern const QString CREATED_AT;
    __declspec(dllexport) extern const QString UPDATED_AT;
    __declspec(dllexport) extern const QString DELETED_AT;
    __declspec(dllexport) extern const QString text_;
    __declspec(dllexport) extern const QString Prepared;
    __declspec(dllexport) extern const QString Unprepared;
    __declspec(dllexport) extern const QString null_;
    __declspec(dllexport) extern const QString Version;
    __declspec(dllexport) extern const QString NOTE;
    __declspec(dllexport) extern const QString pivot_;
    __declspec(dllexport) extern const QString HASH_;
    __declspec(dllexport) extern const QString Progress;

    
    __declspec(dllexport) extern const QString TMPL_ONE;
    __declspec(dllexport) extern const QString PARENTH_ONE;
    __declspec(dllexport) extern const QString DOT_IN;
    __declspec(dllexport) extern const QString SPACE_IN;
    __declspec(dllexport) extern const QString NOSPACE;
    __declspec(dllexport) extern const QString NOSPACE3;
    __declspec(dllexport) extern const QString TMPL_PLURAL;
    __declspec(dllexport) extern const QString TMPL_SQUOTES;
    __declspec(dllexport) extern const QString TMPL_DQUOTES;

    
    __declspec(dllexport) extern const QString QMYSQL;
    __declspec(dllexport) extern const QString QPSQL;
    __declspec(dllexport) extern const QString QSQLITE;
    __declspec(dllexport) extern const QString MYSQL_;
    __declspec(dllexport) extern const QString POSTGRESQL;
    __declspec(dllexport) extern const QString SQLITE;

    __declspec(dllexport) extern const QString driver_;
    __declspec(dllexport) extern const QString host_;
    __declspec(dllexport) extern const QString port_;
    __declspec(dllexport) extern const QString database_;
    __declspec(dllexport) extern const QString schema_;
    __declspec(dllexport) extern const QString search_path;
    __declspec(dllexport) extern const QString username_;
    __declspec(dllexport) extern const QString password_;
    __declspec(dllexport) extern const QString charset_;
    __declspec(dllexport) extern const QString collation_;
    __declspec(dllexport) extern const QString timezone_;
    __declspec(dllexport) extern const QString prefix_;
    __declspec(dllexport) extern const QString options_;
    __declspec(dllexport) extern const QString strict_;
    __declspec(dllexport) extern const QString engine_;
    __declspec(dllexport) extern const QString dont_drop;
    __declspec(dllexport) extern const QString qt_timezone;

    
    __declspec(dllexport) extern const QString SSL_CERT;
    __declspec(dllexport) extern const QString SSL_KEY;
    __declspec(dllexport) extern const QString SSL_CA;
    __declspec(dllexport) extern const QString &ssl_cert;
    __declspec(dllexport) extern const QString &ssl_key;
    __declspec(dllexport) extern const QString &ssl_ca;

    
    __declspec(dllexport) extern const QString sslmode_;
    __declspec(dllexport) extern const QString sslcert;
    __declspec(dllexport) extern const QString sslkey;
    __declspec(dllexport) extern const QString sslrootcert;
    __declspec(dllexport) extern const QString verify_ca;
    __declspec(dllexport) extern const QString verify_full;

    __declspec(dllexport) extern const QString isolation_level;
    __declspec(dllexport) extern const QString foreign_key_constraints;
    __declspec(dllexport) extern const QString check_database_exists;
    __declspec(dllexport) extern const QString prefix_indexes;
    __declspec(dllexport) extern const QString return_qdatetime;
    __declspec(dllexport) extern const QString application_name;
    __declspec(dllexport) extern const QString synchronous_commit;
    __declspec(dllexport) extern const QString spatial_ref_sys;

    __declspec(dllexport) extern const QString H127001;
    __declspec(dllexport) extern const QString LOCALHOST;
    __declspec(dllexport) extern const QString P3306;
    __declspec(dllexport) extern const QString P5432;
    __declspec(dllexport) extern const QString ROOT;
    __declspec(dllexport) extern const QString UTC;
    __declspec(dllexport) extern const QString LOCAL; 
    __declspec(dllexport) extern const QString DEFAULT; 
    __declspec(dllexport) extern const QString SYSTEM; 
    __declspec(dllexport) extern const QString TZ00;
    __declspec(dllexport) extern const QString PUBLIC;
    __declspec(dllexport) extern const QString UTF8;
    __declspec(dllexport) extern const QString UTF8MB4;
    __declspec(dllexport) extern const QString InnoDB;
    __declspec(dllexport) extern const QString MyISAM;
    __declspec(dllexport) extern const QString postgres_;

    __declspec(dllexport) extern const QString UTF8Generalci;
    __declspec(dllexport) extern const QString UTF8Unicodeci;
    __declspec(dllexport) extern const QString UTF8MB4Unicode520ci;
    __declspec(dllexport) extern const QString UTF8MB40900aici;
    __declspec(dllexport) extern const QString Uca1400Nopadaici;
    __declspec(dllexport) extern const QString UcsBasic;
    __declspec(dllexport) extern const QString POSIX_;
    __declspec(dllexport) extern const QString NotImplemented;

    
    __declspec(dllexport) extern const QString EQ;
    __declspec(dllexport) extern const QString NE;
    __declspec(dllexport) extern const QString LT;
    __declspec(dllexport) extern const QString LE;
    __declspec(dllexport) extern const QString GT;
    __declspec(dllexport) extern const QString GE;
    __declspec(dllexport) extern const QString OR;
    __declspec(dllexport) extern const QString AND;
    __declspec(dllexport) extern const QString NOT;
    __declspec(dllexport) extern const QString LIKE;
    __declspec(dllexport) extern const QString NLIKE;
    __declspec(dllexport) extern const QString ILIKE;

    
    __declspec(dllexport) extern const QString NE_;
    __declspec(dllexport) extern const QString OR_;
    __declspec(dllexport) extern const QString AND_;
    __declspec(dllexport) extern const QString NOT_;

    
    __declspec(dllexport) extern const QString B_OR;
    __declspec(dllexport) extern const QString B_AND;

} 



#line 181 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants_extern.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants.hpp"


#line 15 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants.hpp"

#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/constants.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/expression.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/expression.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVector"

#pragma external_header(pop)
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/expression.hpp"





namespace Orm::Query
{

    
    class Expression
    {
    public:
        
        inline Expression() noexcept = default;
        
        inline ~Expression() = default;

        
        inline explicit Expression(const QVariant &value);
        
        inline explicit Expression(QVariant &&value) noexcept;

        
        inline Expression(const Expression &) = default;
        
        inline Expression &operator=(const Expression &) = default;

        
        inline Expression(Expression &&) noexcept = default;
        
        inline Expression &operator=(Expression &&) noexcept = default;

        
        inline operator QVariant() const; 

        
        inline const QVariant &getValue() const noexcept;

        
        inline bool operator==(const Expression &) const = default;

    private:
        
        QVariant m_value {};
    };

    

    
    Expression::Expression(const QVariant &value)
        : m_value(value)
    {}

    Expression::Expression(QVariant &&value) noexcept
        : m_value(std::move(value))
    {}

    Expression::operator QVariant() const
    {
        return QVariant::fromValue(*this);
    }

    const QVariant &Expression::getValue() const noexcept
    {
        return m_value;
    }

} 






 template <> struct QMetaTypeId< ::Orm::Query::Expression > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< ::Orm::Query::Expression >("::Orm::Query::Expression", reinterpret_cast< ::Orm::Query::Expression *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  


#line 88 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/expression.hpp"
#line 89 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/expression.hpp"

#line 91 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/expression.hpp"
#line 15 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"





namespace Orm
{
    
    using namespace Orm::Constants;

    class DatabaseConnection;

namespace Query
{
    class Builder;
}
    using QueryBuilder = Query::Builder;

    
    using ReconnectorType = std::function<void(const DatabaseConnection &)>;

    
    using Column = std::variant<QString, Query::Expression>;

    
    using FromClause = std::variant<std::monostate, QString, Query::Expression>;

    
    enum struct BindingType
    {
        SELECT,
        FROM,
        JOIN,
        WHERE,
        GROUPBY,
        HAVING,
        ORDER,
        UNION,
        UNIONORDER,
    };

    
    using BindingsMap = QMap<BindingType, QVector<QVariant>>;

    
    struct AggregateItem
    {
        QString         function;
        QVector<Column> columns;
    };

    
    enum struct WhereType
    {
        UNDEFINED = -1,
        BASIC,
        NESTED,
        COLUMN,
        IN_,
        NOT_IN,
        NULL_,
        NOT_NULL,
        RAW,
        EXISTS,
        NOT_EXISTS,
        ROW_VALUES,
        BETWEEN,
        BETWEEN_COLUMNS,
        DATE,
        TIME,
        DAY,
        MONTH,
        YEAR,
    };

    
    enum struct HavingType
    {
        UNDEFINED = -1,
        BASIC,
        RAW,
    };

    
    struct HavingConditionItem
    {
        Column     column     {};
        QVariant   value      {};
        QString    comparison {Orm::Constants::EQ};
        QString    condition  {Orm::Constants::AND};
        HavingType type       {HavingType::UNDEFINED};
        QString    sql        {}; 
    };

    
    struct OrderByItem
    {
        Column      column    {};
        QString     direction {Orm::Constants::ASC};
        QString     sql       {}; 
    };

    
    struct UpdateItem
    {
        QString  column;
        QVariant value;
    };

    
    struct WhereItem
    {
        Column   column;
        QVariant value;
        QString  comparison {Orm::Constants::EQ};
        QString  condition  {};
    };

    
    struct WhereColumnItem
    {
        Column  first;
        Column  second;
        QString comparison {Orm::Constants::EQ};
        QString condition  {};
    };

    
    struct WhereBetweenItem
    {
        QVariant min {};
        QVariant max {};
    };

    
    struct WhereBetweenColumnsItem
    {
        Column min {};
        Column max {};
    };

    
    struct WhereConditionItem
    {
        Column                        column         {};
        QVariant                      value          {};
        QString                       comparison     {Orm::Constants::EQ};
        QString                       condition      {Orm::Constants::AND};
        WhereType                     type           {WhereType::UNDEFINED};
        std::shared_ptr<QueryBuilder> nestedQuery    {nullptr};
        QVector<Column>               columns        {};
        QVector<QVariant>             values         {};
        Column                        columnTwo      {};
        QString                       sql            {}; 
        bool                          nope           {false};
        WhereBetweenItem              between        {};
        WhereBetweenColumnsItem       betweenColumns {};
    };

    
    enum struct QtTimeZoneType
    {
        
        DontConvert,
        
        QtTimeSpec,
        
        QTimeZone,
        
        OffsetFromUtc,
    };

    

    struct QtTimeZoneConfig
    {
        
        QtTimeZoneType type  {QtTimeZoneType::QtTimeSpec};
        
        QVariant       value {Qt::UTC}; 

        
        inline bool operator==(const QtTimeZoneConfig &) const = default;
    };

} 





 template <> struct QMetaTypeId< QTimeZone > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QTimeZone >("QTimeZone", reinterpret_cast< QTimeZone *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  
 template <> struct QMetaTypeId< Qt::TimeSpec > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< Qt::TimeSpec >("Qt::TimeSpec", reinterpret_cast< Qt::TimeSpec *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  


 template <> struct QMetaTypeId< ::Orm::WhereConditionItem > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< ::Orm::WhereConditionItem >("::Orm::WhereConditionItem", reinterpret_cast< ::Orm::WhereConditionItem *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  
 template <> struct QMetaTypeId< ::Orm::QtTimeZoneConfig > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< ::Orm::QtTimeZoneConfig >("::Orm::QtTimeZoneConfig", reinterpret_cast< ::Orm::QtTimeZoneConfig *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  
 template <> struct QMetaTypeId< ::Orm::QtTimeZoneType > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< ::Orm::QtTimeZoneType >("::Orm::QtTimeZoneType", reinterpret_cast< ::Orm::QtTimeZoneType *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  




#line 218 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"
#line 219 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"

#line 221 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormtypes.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/sqlquery.hpp"



namespace Orm
{
namespace Query::Grammars
{
    class Grammar;
}

namespace Types
{

    
    class __declspec(dllexport) SqlQuery : public QSqlQuery
    {
        
        using QueryGrammar = Query::Grammars::Grammar;

    public:
        
        inline SqlQuery() = delete;
        
        inline ~SqlQuery() = default;

        
        SqlQuery(const SqlQuery &other) = delete;
        
        SqlQuery &operator=(const SqlQuery &other) = delete;
        
        SqlQuery(SqlQuery &&other) noexcept = default;
        
        SqlQuery &operator=(SqlQuery &&other) noexcept = default;

        
        SqlQuery(QSqlQuery &&other, const QtTimeZoneConfig &qtTimeZone,
                 const QueryGrammar &queryGrammar,
                 std::optional<bool> returnQDateTime);

        
        inline QVariant value(int index) const;
        
        inline QVariant value(const QString &name) const;

    private:
        
        QVariant valueInternal(QVariant &&value) const;

        
        bool shouldPrepareDateTime(const QVariant &value) const;

        
        std::optional<std::variant<QDateTime, QDate>>
        prepareDateTime(const QVariant &value) const;
        
        static std::optional<QDate> asDate(const QString &value);
        
        std::optional<QDateTime> asDateTime(const QString &value) const;

        
        QtTimeZoneConfig m_qtTimeZone;
        
        bool m_isConvertingTimeZone;

        
        bool m_isSQLiteDb;
        
        std::optional<QString> m_dateFormat;
        
        std::optional<bool> m_returnQDateTime;
    };

    

    QVariant SqlQuery::value(const int index) const
    {
        return valueInternal(QSqlQuery::value(index));
    }

    QVariant SqlQuery::value(const QString &name) const
    {
        return valueInternal(QSqlQuery::value(name));
    }

} 

    using SqlQuery = Types::SqlQuery;

} 



#line 107 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/sqlquery.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/concerns/buildsqueries.hpp"



namespace Orm::Query::Concerns
{

    
    class __declspec(dllexport) BuildsQueries 
    {
    public:
        
        inline BuildsQueries() = default;
        
        inline virtual ~BuildsQueries() = 0;

        
        inline BuildsQueries(const BuildsQueries &) = default;
        

        BuildsQueries &operator=(const BuildsQueries &) = delete;

        
        inline BuildsQueries(BuildsQueries &&) = default;
        

        BuildsQueries &operator=(BuildsQueries &&) = delete;

        
        bool chunk(qint64 count,
                   const std::function<bool(SqlQuery &results, qint64 page)> &callback);
        
        bool each(const std::function<bool(SqlQuery &row, qint64 index)> &callback,
                  qint64 count = 1000);

        



        
        bool chunkById(qint64 count,
                       const std::function<
                           bool(SqlQuery &results, qint64 page)> &callback,
                       const QString &column = "", const QString &alias = "");
        
        bool eachById(const std::function<bool(SqlQuery &row, qint64 index)> &callback,
                      qint64 count = 1000, const QString &column = "",
                      const QString &alias = "");


        

        SqlQuery sole(const QVector<Column> &columns = {ASTERISK});

        
        Builder &tap(const std::function<void(Builder &query)> &callback);

    private:
        
        Builder &builder() noexcept;
        
        const Builder &builder() const noexcept;
    };

    

    BuildsQueries::~BuildsQueries() = default;

} 



#line 81 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/concerns/buildsqueries.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/grammars/grammar.hpp"
#pragma once




__pragma(system_header)




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/basegrammar.hpp"
#pragma once




__pragma(system_header)


#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormconcepts.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormconcepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormconcepts.hpp"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"





#pragma once








#line 16 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend _Deque_unchecked_const_iterator operator+(
        const difference_type _Off, _Deque_unchecked_const_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    _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 142 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    const _Container_base12* _Getcont() const noexcept { 
        return _Mycont;
    }

    const _Mydeque* _Mycont;
    _Size_type _Myoff; 
};

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;
    }

    [[nodiscard]] friend _Deque_unchecked_iterator operator+(
        const difference_type _Off, _Deque_unchecked_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    _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>
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());

        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 262, 0, "%s", "cannot dereference value-initialized deque iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot dereference value-initialized deque iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 262, 0); } while (false); } ; } while (false);
        do { if (_Mycont->_Myoff <= this->_Myoff && this->_Myoff < _Mycont->_Myoff + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 264, 0, "%s", "cannot deference out of range deque iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot deference out of range deque iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 264, 0); } while (false); } ; } while (false);
#line 265 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
#line 266 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 279, 0, "%s", "cannot increment value-initialized deque iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment value-initialized deque iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 279, 0); } while (false); } ; } while (false);
        do { if (this->_Myoff < _Mycont->_Myoff + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 280, 0, "%s", "cannot increment deque iterator past end")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot increment deque iterator past end\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 280, 0); } while (false); } ; } while (false);
#line 282 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        ++_Myoff;
        return *this;
    }

    _Deque_const_iterator operator++(int) noexcept {
        _Deque_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    _Deque_const_iterator& operator--() noexcept {

        const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
        do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 296, 0, "%s", "cannot decrement value-initialized deque iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement value-initialized deque iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 296, 0); } while (false); } ; } while (false);
        do { if (_Mycont->_Myoff < this->_Myoff) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 297, 0, "%s", "cannot decrement deque iterator before begin")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot decrement deque iterator before begin\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 297, 0); } while (false); } ; } while (false);
#line 299 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {

        if (_Off != 0) {
            const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
            do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 314, 0, "%s", "cannot seek value-initialized deque iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek value-initialized deque iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 314, 0); } while (false); } ; } while (false);
            do { if (_Mycont->_Myoff <= this->_Myoff + _Off && this->_Myoff + _Off <= _Mycont->_Myoff + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 317, 0, "%s", "cannot seek deque iterator out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek deque iterator out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 317, 0); } while (false); } ; } while (false);
#line 318 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
        }
#line 320 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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;
    }

    [[nodiscard]] friend _Deque_const_iterator operator+(
        const difference_type _Off, _Deque_const_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    _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 388 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    void _Compat(const _Deque_const_iterator& _Right) const noexcept { 


#line 393 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
        do { if (this->_Getcont() == _Right._Getcont()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 393, 0, "%s", "deque iterators incompatible")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque iterators incompatible\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 393, 0); } while (false); } ; } while (false);
#line 395 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 {


#line 411 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
        if (_Off != 0) {
            const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
            do { if (_Mycont) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 413, 0, "%s", "cannot use value-initialized deque iterator")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot use value-initialized deque iterator\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 413, 0); } while (false); } ; } while (false);
            do { if (_Mycont->_Myoff <= this->_Myoff + _Off && this->_Myoff + _Off <= _Mycont->_Myoff + _Mycont->_Mysize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 416, 0, "%s", "cannot seek deque iterator out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"cannot seek deque iterator out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 416, 0); } while (false); } ; } while (false);
#line 417 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
        }
#line 419 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
    }


    friend void _Verify_range(const _Deque_const_iterator& _First, const _Deque_const_iterator& _Last) noexcept {
        
        do { if (_First <= _Last) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 424, 0, "%s", "deque iterators transposed")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque iterators transposed\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 424, 0); } while (false); } ; } while (false);
    }
#line 427 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    void _Seek_to(const _Deque_unchecked_const_iterator<_Mydeque>& _UIt) noexcept {
        _Myoff = _UIt._Myoff;
    }

    _Size_type _Myoff; 
};

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 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;
    }

    [[nodiscard]] friend _Deque_iterator operator+(const difference_type _Off, _Deque_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    _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 _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    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 N4950 [container.alloc.reqmts]/5)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this error.");
    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
                                    "because of [container.requirements].");

    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 _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, _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(__declspec(guard(overflow)) 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());
        _Tidy_guard<deque> _Guard{this};
        resize(_Count);
        _Guard._Target = nullptr;
        _Proxy._Release();
    }

    deque(__declspec(guard(overflow)) 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(__declspec(guard(overflow)) 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();
    }

















#line 695 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

private:
    template <class _Iter, class _Sent>
    void _Construct(_Iter _First, const _Sent _Last) { 
        _Tidy_guard<deque> _Guard{this};
        for (; _First != _Last; ++_First) {
            _Emplace_back_internal(*_First);
        }

        _Guard._Target = nullptr;
    }

    void _Construct_n(size_type _Count, const _Ty& _Val) { 
        _Tidy_guard<deque> _Guard{this};
        for (; _Count > 0; --_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);
    }

    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));
    }


























#line 821 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    void push_back(_Ty&& _Val) {
        _Orphan_all();
        _Emplace_back_internal(::std:: move(_Val));
    }
















#line 843 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    iterator insert(const_iterator _Where, _Ty&& _Val) {
        return emplace(_Where, ::std:: move(_Val));
    }

    template <class... _Valty>
    decltype(auto) emplace_front(_Valty&&... _Val) {
        _Orphan_all();
        _Emplace_front_internal(::std:: forward<_Valty>(_Val)...);

        return front();
#line 855 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
    }

    template <class... _Valty>
    decltype(auto) emplace_back(_Valty&&... _Val) {
        _Orphan_all();
        _Emplace_back_internal(::std:: forward<_Valty>(_Val)...);


        return back();
#line 865 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
    }

    template <class... _Valty>
    iterator emplace(const_iterator _Where, _Valty&&... _Val) {
        const auto _Off = static_cast<size_type>(_Where - begin());


        do { if (_Off <= _Mysize()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 872, 0, "%s", "deque emplace iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque emplace iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 872, 0); } while (false); } ; } while (false);
#line 874 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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() && _Mapsize() > 0)
            || (!empty() && size() <= _Newcapacity && _Newcapacity < _Oldcapacity)) { 
            deque _Tmp(::std:: make_move_iterator(begin()), ::std:: make_move_iterator(end()));
            swap(_Tmp);
        }
    }

    void resize(__declspec(guard(overflow)) size_type _Newsize) {
        _Orphan_all();
        while (_Mysize() < _Newsize) {
            _Emplace_back_internal();
        }

        while (_Mysize() > _Newsize) {
            pop_back();
        }
    }

    void resize(__declspec(guard(overflow)) size_type _Newsize, const _Ty& _Val) {
        _Orphan_all();
        while (_Mysize() < _Newsize) {
            _Emplace_back_internal(_Val);
        }

        while (_Mysize() > _Newsize) {
            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("This member function returns a bool indicating whether the container is empty and has no other effects. " "It is not useful to call this member function and discard the return value. " "Use the 'clear()' member function if you want to erase all elements.")]] 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  {

        do { if (_Pos < _Mysize()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1072, 0, "%s", "deque subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1072, 0); } while (false); } ; } while (false);
#line 1074 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return *(_Unchecked_begin() + static_cast<difference_type>(_Pos));
    }

    [[nodiscard]] reference operator[](size_type _Pos) noexcept  {

        do { if (_Pos < _Mysize()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1080, 0, "%s", "deque subscript out of range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque subscript out of range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1080, 0); } while (false); } ; } while (false);
#line 1082 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return *(_Unchecked_begin() + static_cast<difference_type>(_Pos));
    }

    [[nodiscard]] reference front() noexcept  {

        do { if (!empty()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1088, 0, "%s", "front() called on empty deque")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty deque\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1088, 0); } while (false); } ; } while (false);
#line 1090 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return *_Unchecked_begin();
    }

    [[nodiscard]] const_reference front() const noexcept  {

        do { if (!empty()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1096, 0, "%s", "front() called on empty deque")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"front() called on empty deque\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1096, 0); } while (false); } ; } while (false);
#line 1098 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return *_Unchecked_begin();
    }

    [[nodiscard]] reference back() noexcept  {

        do { if (!empty()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1104, 0, "%s", "back() called on empty deque")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty deque\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1104, 0); } while (false); } ; } while (false);
#line 1106 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return *_Prev_iter(_Unchecked_end());
    }

    [[nodiscard]] const_reference back() const noexcept  {

        do { if (!empty()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1112, 0, "%s", "back() called on empty deque")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"back() called on empty deque\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1112, 0); } while (false); } ; } while (false);
#line 1114 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return *_Prev_iter(_Unchecked_end());
    }

    void push_front(const _Ty& _Val) {
        emplace_front(_Val);
    }

    void pop_front() noexcept  {

        if (empty()) {
            do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1125, 0, "%s", "deque empty before pop")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque empty before pop\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1125, 0); } while (false);
        } else { 
            _Orphan_off(_Myoff());
            size_type _Block = _Getblock(_Myoff());
            _Alty_traits::destroy(_Getal(), _Unfancy(_Map()[_Block] + _Myoff() % _Block_size));
            if (--_Mysize() == 0) {
                _Myoff() = 0;
            } else {
                ++_Myoff();
            }
        }









#line 1146 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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();
    }

    template <class... _Tys>
    void _Emplace_front_internal(_Tys&&... _Vals) {
        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;
        const 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)...);

        _Myoff() = _Newoff;
        ++_Mysize();
    }

public:
    void push_back(const _Ty& _Val) {
        _Orphan_all();
        _Emplace_back_internal(_Val);
    }

    void pop_back() noexcept  {

        if (empty()) {
            do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1195, 0, "%s", "deque empty before pop")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque empty before pop\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1195, 0); } while (false);
        } else { 
            size_type _Newoff = _Myoff() + _Mysize() - 1;
            _Orphan_off(_Newoff);
            size_type _Block = _Getblock(_Newoff);
            _Alty_traits::destroy(_Getal(), _Unfancy(_Map()[_Block] + _Newoff % _Block_size));
            if (--_Mysize() == 0) {
                _Myoff() = 0;
            }
        }








#line 1214 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
    }

private:
    template <class _Iter, class _Sent>
    void _Assign_range(_Iter _First, const _Sent _Last) {
        _Orphan_all();
        auto _Myfirst      = _Unchecked_begin();
        const auto _Mylast = _Unchecked_end();
        
        for (; _Myfirst != _Mylast; ++_Myfirst, (void) ++_First) {
            if (_First == _Last) {
                _Erase_last_n(static_cast<size_type>(_Mylast - _Myfirst));
                return;
            }

            *_Myfirst = *_First;
        }

        
        for (; _First != _Last; ++_First) {
            _Emplace_back_internal(*_First);
        }
    }

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_range(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }






#line 1251 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    void assign(__declspec(guard(overflow)) size_type _Count, const _Ty& _Val) { 
        _Orphan_all();
        auto _Myfirst       = _Unchecked_begin();
        const auto _Oldsize = _Mysize();
        auto _Assign_count  = (::std:: min)(_Count, _Oldsize);
        for (; _Assign_count > 0; --_Assign_count) {
            *_Myfirst = _Val;
            ++_Myfirst;
        }

        const auto _Shrink_by = _Oldsize - _Assign_count;
        auto _Extend_by       = _Count - _Assign_count;
        _Erase_last_n(_Shrink_by);
        for (; _Extend_by > 0; --_Extend_by) {
            _Emplace_back_internal(_Val);
        }
    }

    iterator insert(const_iterator _Where, const _Ty& _Val) {
        size_type _Off = static_cast<size_type>(_Where - begin());


        do { if (_Off <= _Mysize()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1274, 0, "%s", "deque insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1274, 0); } while (false); } ; } while (false);
#line 1276 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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, __declspec(guard(overflow)) 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);
    }

private:
    enum class _Pop_direction : bool {
        _Front,
        _Back,
    };

    template <_Pop_direction _Direction>
    struct [[nodiscard]] _Restore_old_size_guard {
        deque* _Container;
        const size_type _Oldsize;

        ~_Restore_old_size_guard() { 
            if (_Container) {
                while (_Oldsize < _Container->_Mysize()) {
                    if constexpr (_Direction == _Pop_direction::_Front) {
                        _Container->pop_front();
                    } else {
                        _Container->pop_back();
                    }
                }
            }
        }
    };

    enum class _Is_bidi : bool { _Nope, _Yes };

    template <_Is_bidi _Bidi, class _Iter, class _Sent>
    iterator _Insert_range(const size_type _Off, _Iter _First, _Sent _Last) {
        
        
        


        do { if (_Mysize() >= _Off) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1328, 0, "%s", "deque insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1328, 0); } while (false); } ; } while (false);
#line 1330 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        if (_First == _Last) {
            return begin() + static_cast<difference_type>(_Off);
        }

        const size_type _Oldsize = _Mysize();

        _Orphan_all();
        if (_Off <= _Oldsize / 2) { 
            _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
            if constexpr (_Bidi == _Is_bidi::_Yes) {
                while (_First != _Last) {
                    _Emplace_front_internal(*--_Last); 
                }
            } else {
                for (; _First != _Last; ++_First) {
                    _Emplace_front_internal(*_First); 
                }
            }

            _Guard._Container = nullptr;

            const auto _Num     = static_cast<difference_type>(_Mysize() - _Oldsize);
            const auto _Myfirst = _Unchecked_begin();
            const auto _Mymid   = _Myfirst + _Num;
            if constexpr (_Bidi == _Is_bidi::_Nope) {
                ::std:: reverse(_Myfirst, _Mymid); 
            }
            ::std:: rotate(_Myfirst, _Mymid, _Mymid + static_cast<difference_type>(_Off));
            return begin() + static_cast<difference_type>(_Off);
        }

        _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
        for (; _First != _Last; ++_First) {
            _Emplace_back_internal(*_First);
        }

        _Guard._Container = nullptr;

        const auto _Myfirst = _Unchecked_begin();
        ::std:: rotate(_Myfirst + static_cast<difference_type>(_Off), _Myfirst + static_cast<difference_type>(_Oldsize),
            _Unchecked_end());

        return begin() + static_cast<difference_type>(_Off);
    }

public:
    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
        
        _Adl_verify_range(_First, _Last);
        const size_type _Off = static_cast<size_type>(_Where - begin());
        return _Insert_range<static_cast<_Is_bidi>(_Is_cpp17_bidi_iter_v<_Iter>)>(
            _Off, _Get_unwrapped(_First), _Get_unwrapped(_Last));
    }













#line 1399 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

    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);


        do { if (_First <= _Last && begin() <= _First && _Last <= end()) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1410, 0, "%s", "deque erase iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque erase iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1410, 0); } while (false); } ; } while (false);
        _Adl_verify_range(_First, _Last);

        auto _Off   = static_cast<size_type>(_First - begin());
        auto _Count = static_cast<size_type>(_Last - _First);
        bool _Moved = _Off > 0 && _Off + _Count < _Mysize();




#line 1421 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        if (_Count == 0) {
            return _First;
        }

        if (_Off < static_cast<size_type>(end() - _Last)) { 
            ::std:: move_backward(begin(), _First, _Last); 
            for (; _Count > 0; --_Count) {
                pop_front(); 
            }
        } else { 
            ::std:: move(_Last, end(), _First); 
            for (; _Count > 0; --_Count) {
                pop_back(); 
            }
        }


        if (_Moved) {
            _Orphan_all();
        }
#line 1443 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        return begin() + static_cast<difference_type>(_Off);
    }

private:
    void _Erase_last_n(size_type _Count) noexcept {
        for (; _Count > 0; --_Count) {
            pop_back();
        }
    }

public:
    void clear() noexcept { 
        _Tidy();
    }

    void swap(deque& _Right) noexcept  {
        using ::std:: swap;
        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(_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;


        do { if (_Off <= _Oldsize) { } else { do { (void) ((1 != _CrtDbgReport(2, "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1482, 0, "%s", "deque insert iterator outside range")) || (__debugbreak(), 0)); ::_invalid_parameter(L"\"deque insert iterator outside range\"", L"", L"\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque", 1482, 0); } while (false); } ; } while (false);
#line 1484 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"

        if (_Off < _Rem) { 
            _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
            if (_Off < _Count) { 
                for (_Num = _Count - _Off; _Num > 0; --_Num) {
                    push_front(_Val); 
                }
                for (_Num = _Off; _Num > 0; --_Num) {
                    push_front(begin()[static_cast<difference_type>(_Count - 1)]); 
                }

                _Mid = begin() + static_cast<difference_type>(_Count);
                ::std:: fill_n(_Mid, _Off, _Val); 
            } else { 
                for (_Num = _Count; _Num > 0; --_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()); 
            }
            _Guard._Container = nullptr;
        } else { 
            _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
            if (_Rem < _Count) { 
                _Orphan_all();
                for (_Num = _Count - _Rem; _Num > 0; --_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_n(_Mid, _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_n(_Mid, _Count, _Tmp._Get_value()); 
            }
            _Guard._Container = nullptr;
        }
    }

    [[noreturn]] static void _Xlen() {
        _Xlength_error("deque<T> too long");
    }

    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid deque<T> subscript");
    }

    void _Growmap(size_type _Count) { 
        static_assert(_Minimum_map_size > 1, "The _Xlen() test should always be performed.");

        _Alpty _Almap(_Getal());
        size_type _Newsize = _Mapsize() > 0 ? _Mapsize() : 1;
        while (_Newsize - _Mapsize() < _Count || _Newsize < _Minimum_map_size) {
            
            if (max_size() / _Block_size - _Newsize < _Newsize) {
                _Xlen(); 
            }

            _Newsize *= 2;
        }

        size_type _Myboff = _Myoff() / _Block_size;
        _Mapptr _Newmap   = _Allocate_at_least_helper(_Almap, _Newsize);
        _Mapptr _Myptr    = _Newmap + _Myboff;

        _Count = _Newsize - _Mapsize();

        _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); 
        }

        if (_Map() != nullptr) {
            _Destroy_range(_Map(), _Map() + _Mapsize());
            _Almap.deallocate(_Map(), _Mapsize()); 
        }

        _Map() = _Newmap; 
        _Mapsize() += _Count;
    }

    void _Tidy() noexcept { 
        _Orphan_all();

        _Alpty _Almap(_Getal());
        while (!empty()) {
            pop_back();
        }

        if (_Map() != nullptr) {
            for (size_type _Block = _Mapsize(); _Block > 0;) { 
                if (_Map()[--_Block]) { 
                    _Getal().deallocate(_Map()[_Block], _Block_size);
                }
                _Destroy_in_place(_Map()[_Block]); 
            }

            _Almap.deallocate(_Map(), _Mapsize()); 
        }

        _Mapsize() = 0;
        _Map()     = nullptr;
    }


    void _Orphan_off(size_type _Offlo) const noexcept { 
        size_type _Offhigh = _Myoff() + _Mysize() <= _Offlo + 1 ? static_cast<size_type>(-1) : _Offlo;
        if (_Offlo == _Myoff()) {
            _Offlo = 0;
        }

        _Lockit _Lock(3);
        _Iterator_base12** _Pnext = &_Get_data()._Myproxy->_Myfirstiter;
        while (*_Pnext) {
            const auto _Pnextoff = static_cast<const_iterator&>(**_Pnext)._Myoff;
            if (_Pnextoff < _Offlo || _Offhigh < _Pnextoff) {
                _Pnext = &(*_Pnext)->_Mynextiter;
            } else { 
                (*_Pnext)->_Myproxy = nullptr;
                *_Pnext             = (*_Pnext)->_Mynextiter;
            }
        }
    }
#line 1630 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1695 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"





#line 1701 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1719 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1748 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\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 1760 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"


namespace pmr {
     template <class _Ty>
    using deque = ::std:: deque<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 1767 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
}



#pragma warning(pop)
#pragma pack(pop)
#line 1774 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
#line 1775 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\deque"
#pragma external_header(pop)
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormconcepts.hpp"








namespace Orm
{
namespace Query
{
    class Builder;
    class Expression;
}
    using QueryBuilder = Query::Builder;

    



    
    template<typename T>
    concept Queryable = std::convertible_to<T, Orm::QueryBuilder &> ||
                        std::invocable<T, Orm::QueryBuilder &>;

    
    template<typename T>
    concept QueryableShared =
            Queryable<T> ||
            std::convertible_to<T, const std::shared_ptr<Orm::QueryBuilder> &>;

    
    template<typename T>
    concept WhereValueSubQuery = Queryable<T>;

    
    template<typename T>
    concept SubQuery = std::convertible_to<T, QString> ||
                       Queryable<T>;

    
    template<typename T>
    concept WhereValue = std::convertible_to<T, QVariant> ||
                         WhereValueSubQuery<T>;

    
    template<typename T>
    concept JoinTable = std::same_as<T, Query::Expression> ||
                        std::convertible_to<T, QString>;

    
    template<typename T>
    concept ColumnConcept =
            std::convertible_to<T, std::variant<QString, Query::Expression>>;

    
    template<typename T>
    concept QStringConcept = std::convertible_to<T, QString>;

    
    template<typename T>
    concept QVariantConcept = std::convertible_to<T, QVariant>;

    
    using Column = std::variant<QString, Query::Expression>;

    
    template<typename T>
    concept ColumnContainer = std::convertible_to<T, QStringList> ||
                              std::convertible_to<T, QVector<QString>> ||
                              std::convertible_to<T, QVector<Column>>;

    
    template<typename T>
    concept JoinContainer = ColumnContainer<T> ||
                            std::convertible_to<T, std::set<QString>> ||
                            std::convertible_to<T, std::deque<QString>> ||
                            std::convertible_to<T, std::vector<QString>> ||

                            std::convertible_to<T, QList<QStringView>> ||
#line 94 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormconcepts.hpp"
                            std::convertible_to<T, QVector<QStringView>> ||
                            std::convertible_to<T, QSet<QString>>;

    
    template<typename T>
    concept DelimiterConcept = std::convertible_to<T, QString> ||
                               std::convertible_to<T, QChar>;

    
    template<typename T>
    concept QStringContainer = JoinContainer<T> &&
                               !std::convertible_to<T, QVector<Column>>;

} 



#line 112 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/ormconcepts.hpp"
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/basegrammar.hpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/container.hpp"
#pragma once




__pragma(system_header)






namespace Orm::Utils
{

    
    class Container
    {
        Container(const Container &) = delete; Container &operator=(const Container &) = delete; Container(Container &&) = delete; Container &operator=(Container &&) = delete;

    public:
        
        Container() = delete;
        
        ~Container() = delete;

        
        template<JoinContainer T, DelimiterConcept D = const QString &>
        static QString
        join(const T &container, D &&delimiter = Constants::COMMA);

        

        template<QStringContainer T, typename SizeType = typename T::size_type>
        static SizeType
        countStringSizes(const T &container, typename T::size_type addToElement = 0);

    private:
        
        template<typename SizeType = QString::size_type, DelimiterConcept D>
        static SizeType delimiterSize(D &&delimiter);
    };

    template<JoinContainer T, DelimiterConcept D>
    QString Container::join(const T &container, D &&delimiter)
    {
        
        if (container.empty())
            return {};

        QString joined;
        
        const auto delimiterSize_ = delimiterSize<typename T::size_type>(delimiter);
        joined.reserve(static_cast<QString::size_type>(
                           countStringSizes(container, delimiterSize_ + 4)));

        auto it = container.cbegin();
        const auto end = container.cend();

        
        if (it != end) {
            joined.append(*it);
            ++it;
        }

        while (it != end) {
            
            
            joined.append(delimiter)
                  .append(*it);
            ++it;
        }

        ((it == end) ? static_cast<void>(0) : qt_assert("it == end", "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/container.hpp", 74));

        return joined;
    }

    template<QStringContainer T, typename SizeType>
    SizeType
    Container::countStringSizes(const T &container,
                                const typename T::size_type addToElement)
    {
        
        if (container.empty())
            return 0;

        SizeType size = 0;

        for (const auto &string : container)
            size += static_cast<SizeType>(string.size()) + addToElement;

        return size;
    }

    

    template<typename SizeType, DelimiterConcept D>
    SizeType Container::delimiterSize(D &&delimiter)
    {
        if constexpr (std::is_constructible_v<QChar, D>)
            return 1;
        else
            return static_cast<SizeType>(QString(delimiter).size());
    }

} 



#line 112 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/container.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/basegrammar.hpp"



namespace Orm
{
namespace Query
{
    class Expression;
}

    

    template<typename T>
    concept Parametrize = std::same_as<T, QVariantMap> ||
                          std::same_as<T, QVector<QVariant>>;

    
    class __declspec(dllexport) BaseGrammar
    {
        BaseGrammar(const BaseGrammar &) = delete; BaseGrammar &operator=(const BaseGrammar &) = delete;

    protected:
        
        using ContainerUtils = Orm::Utils::Container;
        
        using Expression = Query::Expression;

    public:
        
        inline BaseGrammar() = default;
        
        inline virtual ~BaseGrammar() = 0;

        
        virtual const QString &getDateFormat() const;

        
        QString wrap(const QString &value, bool prefixAlias = false) const;
        
        QString wrap(const Column &value) const;

        
        QString wrapTable(const QString &table) const;
        
        QString wrapTable(const FromClause &table) const;

        
        template<ColumnContainer T>
        QVector<QString> wrapArray(const T &values) const;

        
        static QString quoteString(const QString &value);
        
        template<typename = void>
        static QString quoteString(const QVector<QString> &values);

        
        static bool isExpression(const QVariant &value);

        
        static QVariant getValue(const QVariant &expression);
        
        static QVariant getValue(const Expression &expression) noexcept;

        
        inline QString getTablePrefix() const;
        
        BaseGrammar &setTablePrefix(const QString &prefix);

        
        static QString unqualifyColumn(const QString &column);

        
        static QString getFromWithoutAlias(const QString &from);
        
        static QString getAliasFromFrom(const QString &from);
        
        inline static QString getAliasFromColumn(const QString &column);

    protected:
        
        template<ColumnContainer T>
        QString columnize(T &&columns) const;
        
        template<ColumnContainer T>
        QString columnizeWithoutWrap(T &&columns) const;

        
        template<Parametrize Container>
        QString parametrize(const Container &values) const;
        
        static QString parameter(const QVariant &value);

        
        QString wrapAliasedValue(const QString &value, bool prefixAlias = false) const;
        
        virtual QString wrapValue(QString value) const;

        
        QString wrapSegments(QStringList segments) const;

        

        static QStringList getSegmentsFromAlias(const QString &aliasedExpression);

        
        
        QString m_tablePrefix {};
    };

    

    BaseGrammar::~BaseGrammar() = default;

    

    template<ColumnContainer T>
    QString BaseGrammar::columnize(T &&columns) const
    {
        return columnizeWithoutWrap(wrapArray(std::forward<T>(columns)));
    }

    

    template<ColumnContainer T>
    QString BaseGrammar::columnizeWithoutWrap(T &&columns) const
    {
        return ContainerUtils::join(std::forward<T>(columns));
    }

    QString BaseGrammar::getTablePrefix() const
    {
        return m_tablePrefix;
    }

    QString BaseGrammar::getAliasFromColumn(const QString &column)
    {
        
        return getAliasFromFrom(column);
    }

    template<ColumnContainer T>
    QVector<QString> BaseGrammar::wrapArray(const T &values) const
    {
        QVector<QString> wrapped;
        wrapped.reserve(static_cast<QVector<QString>::size_type>(values.size()));

        for (const auto &value : values)
            wrapped << wrap(value);

        return wrapped;
    }

    template<typename>
    QString BaseGrammar::quoteString(const QVector<QString> &values)
    {
        
        if (values.isEmpty())
            return {};

        QString quoted;
        quoted.reserve(ContainerUtils::countStringSizes(values, 4) + 8);

        auto it = values.constBegin();
        const auto end = values.constEnd();

        
        if (it != end) {
            quoted.append(SQUOTE)
                  .append(*it)
                  .append(SQUOTE);
            ++it;
        }

        while (it != end) {
            
            quoted.append(([]() noexcept -> QString { enum { Size = sizeof(u"" ", '")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" ", '" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()))
                  .append(*it)
                  .append(SQUOTE);
            ++it;
        }

        ((it == end) ? static_cast<void>(0) : qt_assert("it == end", "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/basegrammar.hpp", 194));

        return quoted;
    }

    template<Parametrize Container>
    QString BaseGrammar::parametrize(const Container &values) const
    {
        QStringList compiledParameters;
        compiledParameters.reserve(
                    static_cast<QStringList::size_type>(values.size()));

        for (const auto &value : values)
            compiledParameters << parameter(value);

        return columnizeWithoutWrap(compiledParameters);
    }

} 



#line 217 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/basegrammar.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/grammars/grammar.hpp"



namespace Orm::Query::Grammars
{

    
    
    class __declspec(dllexport) Grammar : public BaseGrammar
    {
        Grammar(const Grammar &) = delete; Grammar &operator=(const Grammar &) = delete;

    public:
        
        inline Grammar() = default;
        
        inline ~Grammar() override = 0;

        
        QString compileSelect(QueryBuilder &query) const;

        
        QString compileExists(QueryBuilder &query) const;

        
        virtual QString
        compileInsert(const QueryBuilder &query,
                      const QVector<QVariantMap> &values) const;
        
        virtual QString
        compileInsertOrIgnore(const QueryBuilder &query,
                              const QVector<QVariantMap> &values) const;
        
        inline virtual QString
        compileInsertGetId(const QueryBuilder &query,
                           const QVector<QVariantMap> &values,
                           const QString &sequence) const;

        
        virtual QString
        compileUpdate(QueryBuilder &query, const QVector<UpdateItem> &values) const;
        
        QVector<QVariant>
        prepareBindingsForUpdate(const BindingsMap &bindings,
                                 const QVector<UpdateItem> &values) const;

        
        virtual QString
        compileUpsert(QueryBuilder &query, const QVector<QVariantMap> &values,
                      const QStringList &uniqueBy, const QStringList &update) const;

        
        virtual QString compileDelete(QueryBuilder &query) const;
        
        QVector<QVariant>
        prepareBindingsForDelete(const BindingsMap &bindings) const;

        

        virtual std::unordered_map<QString, QVector<QVariant>>
        compileTruncate(const QueryBuilder &query) const;

        
        virtual QString compileRandom(const QString &seed) const;

        
        virtual const std::unordered_set<QString> &getOperators() const;

    protected:
        
        struct SelectComponentValue
        {
            
            std::function<QString(const Grammar &, const QueryBuilder &)> compileMethod;
            
            std::function<bool(const QueryBuilder &)> isset;
        };
        
        using WhereMemFn = std::function<QString(const Grammar &grammar,
                                                 const WhereConditionItem &)>;

        
        virtual const QVector<SelectComponentValue> &getCompileMap() const = 0;
        
        virtual const WhereMemFn &getWhereMethod(WhereType whereType) const = 0;

        
        static bool shouldCompileAggregate(const std::optional<AggregateItem> &aggregate);
        
        static bool shouldCompileColumns(const QueryBuilder &query);
        
        static bool shouldCompileFrom(const std::variant<std::monostate, QString,
                                      Query::Expression> &from);

        
        QStringList compileComponents(const QueryBuilder &query) const;

        
        QString compileAggregate(const QueryBuilder &query) const;
        
        virtual QString compileColumns(const QueryBuilder &query) const;

        
        QString compileFrom(const QueryBuilder &query) const;

        
        QString compileWheres(const QueryBuilder &query) const;
        
        QStringList compileWheresToVector(const QueryBuilder &query) const;
        
        static QString concatenateWhereClauses(const QueryBuilder &query,
                                               const QStringList &sql);

        
        QString compileJoins(const QueryBuilder &query) const;

        
        QString compileGroups(const QueryBuilder &query) const;

        
        QString compileHavings(const QueryBuilder &query) const;
        
        QString compileHaving(const HavingConditionItem &having) const;
        
        QString compileBasicHaving(const HavingConditionItem &having) const;

        
        QString compileOrders(const QueryBuilder &query) const;
        
        QStringList compileOrdersToVector(const QueryBuilder &query) const;
        
        QString compileLimit(const QueryBuilder &query) const;
        
        QString compileOffset(const QueryBuilder &query) const;

        
        virtual QString compileLock(const QueryBuilder &query) const;

        
        QString whereBasic(const WhereConditionItem &where) const;
        
        QString whereNested(const WhereConditionItem &where) const;
        
        QString whereColumn(const WhereConditionItem &where) const;
        
        QString whereIn(const WhereConditionItem &where) const;
        
        QString whereNotIn(const WhereConditionItem &where) const;
        
        QString whereNull(const WhereConditionItem &where) const;
        
        QString whereNotNull(const WhereConditionItem &where) const;
        
        QString whereRaw(const WhereConditionItem &where) const;
        
        QString whereExists(const WhereConditionItem &where) const;
        
        QString whereNotExists(const WhereConditionItem &where) const;
        
        QString whereRowValues(const WhereConditionItem &where) const;
        
        QString whereBetween(const WhereConditionItem &where) const;
        
        QString whereBetweenColumns(const WhereConditionItem &where) const;

        
        QString whereDate(const WhereConditionItem &where) const;
        
        QString whereTime(const WhereConditionItem &where) const;
        
        QString whereDay(const WhereConditionItem &where) const;
        
        QString whereMonth(const WhereConditionItem &where) const;
        
        QString whereYear(const WhereConditionItem &where) const;
        
        virtual QString
        dateBasedWhere(const QString &type, const WhereConditionItem &where) const;

        
        QStringList compileInsertToVector(const QVector<QVariantMap> &values) const;

        
        virtual QString
        compileUpdateColumns(const QVector<UpdateItem> &values) const;
        
        virtual QString
        compileUpdateWithoutJoins(const QueryBuilder &query, const QString &table,
                                  const QString &columns, const QString &wheres) const;
        
        QString
        compileUpdateWithJoins(const QueryBuilder &query, const QString &table,
                               const QString &columns, const QString &wheres) const;

        
        virtual QString
        compileDeleteWithoutJoins(const QueryBuilder &query, const QString &table,
                                  const QString &wheres) const;
        
        QString
        compileDeleteWithJoins(const QueryBuilder &query, const QString &table,
                               const QString &wheres) const;

        
        static QString concatenate(const QStringList &segments);
        
        static QString removeLeadingBoolean(QString &&statement);

        
        static QVector<std::reference_wrapper<const QVariant>>
        flatBindingsForUpdateDelete(const BindingsMap &bindings,
                                    const QVector<BindingType> &exclude);

        
        static QVector<QVariant>::size_type
        computeReserveForBindingsMap(const BindingsMap &bindings,
                                     const QVector<BindingType> &exclude = {});
    };

    

    Grammar::~Grammar() = default;

    QString Grammar::compileInsertGetId(
            const QueryBuilder &query, const QVector<QVariantMap> &values,
            const QString &) const
    {
        return compileInsert(query, values);
    }

} 



#line 247 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/grammars/grammar.hpp"
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/helpers.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/helpers.hpp"






class QDateTime;
class QVariant; 



namespace Orm
{
    struct QtTimeZoneConfig;

namespace Utils
{
    
    template<class T, class = void>
    struct IsNothrowHashable : std::false_type
    {};

    
    template<class T>
    struct IsNothrowHashable<T, std::void_t<decltype (std::hash<T>()(
                                                          std::declval<const T &>()))>>
        : std::bool_constant<noexcept(std::hash<T>()(std::declval<const T &>()))>
    {};

    
    class __declspec(dllexport) Helpers
    {
        Helpers(const Helpers &) = delete; Helpers &operator=(const Helpers &) = delete; Helpers(Helpers &&) = delete; Helpers &operator=(Helpers &&) = delete;

    public:
        
        Helpers() = delete;
        
        ~Helpers() = delete;

        
        template<typename T>
        static T &&
        tap(T &&value, std::function<void(T &)> &&callback = nullptr)
        requires (!std::is_reference_v<T>);
        
        template<typename T>
        static T &&
        tap(T &&value, std::function<void()> &&callback = nullptr)
        requires (!std::is_reference_v<T>);

        

        template<typename T>
        inline static std::size_t &hashCombine(std::size_t &seed, const T &value)
        noexcept(IsNothrowHashable<std::remove_const_t<T>>::value);

        
        static int qVariantTypeId(const QVariant &value);

        
        [[maybe_unused]]
        static void logException(const std::exception &e, bool fatal = false);

        
        
        static bool isStandardDateFormat(const QString &value);

        
        static QDateTime
        convertTimeZone(const QDateTime &datetime, const QtTimeZoneConfig &timezone);
        
        static QDateTime &
        setTimeZone(QDateTime &datetime, const QtTimeZoneConfig &timezone);
        
        static QDateTime
        setTimeZone(QDateTime &&datetime, const QtTimeZoneConfig &timezone);

        
        static QDateTime
        convertTimeZone(const QDateTime &datetime, const QString &connection = "");
        
        static QDateTime &
        setTimeZone(QDateTime &datetime, const QString &connection = "");
        
        static QDateTime
        setTimeZone(QDateTime &&datetime, const QString &connection = "");

    private:
        

        [[maybe_unused]]
        static void logPluginsPath(const QString &exceptionMessage);
    };

    

    template<typename T>
    T &&
    Helpers::tap(T &&value, std::function<void(T &)> &&callback)
    requires (!std::is_reference_v<T>)
    {
        if (callback)
            std::invoke(callback, value);

        

        return std::forward<T>(value);
    }

    template<typename T>
    T &&
    Helpers::tap(T &&value, std::function<void()> &&callback)
    requires (!std::is_reference_v<T>)
    {
        if (callback)
            std::invoke(callback);

        

        return std::forward<T>(value);
    }

    template<typename T>
    std::size_t &Helpers::hashCombine(std::size_t &seed, const T &value)
    noexcept(IsNothrowHashable<std::remove_const_t<T>>::value)
    {
        return seed ^= std::hash<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }

} 
} 



#line 145 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/helpers.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"

class QSqlQuery;



namespace Orm::Utils
{

    
    template<typename T>
    concept BindingsConcept = std::convertible_to<T, QVector<QVariant>> ||


#line 28 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"
                              std::convertible_to<T, QVariantMap>;
#line 30 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"

    
    class __declspec(dllexport) Query
    {
        Query(const Query &) = delete; Query &operator=(const Query &) = delete; Query(Query &&) = delete; Query &operator=(Query &&) = delete;

        
        using Helpers = Orm::Utils::Helpers;

    public:
        
        Query() = delete;
        
        ~Query() = delete;

        
        static QString parseExecutedQuery(const QSqlQuery &query);
        
        inline static QString
        parseExecutedQueryForPretend(QString queryString,
                                     const QVector<QVariant> &bindings);

        
        template<BindingsConcept T>
        static std::pair<QString, QStringList>
        replaceBindingsInSql(QString queryString, const T &bindings,
                             bool simpleBindings = false);

        
        [[maybe_unused]]
        static void logExecutedQuery(const QSqlQuery &query);

        
        static QVector<QVariantMap>
        zipForInsert(const QVector<QString> &columns,
                     const QVector<QVector<QVariant>> &values);

        
        static int queryResultSize(QSqlQuery &query);
    };

    

    QString Query::parseExecutedQueryForPretend(QString queryString,
                                                const QVector<QVariant> &bindings)
    {
        return replaceBindingsInSql(std::move(queryString), bindings).first;
    }

    template<BindingsConcept T>
    std::pair<QString, QStringList>
    Query::replaceBindingsInSql(QString queryString, const T &bindings,
                                const bool simpleBindings)
    {
        static const auto Invalid = ([]() noexcept -> QString { enum { Size = sizeof(u"" "INVALID")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "INVALID" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }());

        QString bindingValue;

        QStringList simpleBindingsList;
        simpleBindingsList.reserve(
                    static_cast<QStringList::size_type>(bindings.size()));

        for (const auto &binding : bindings) {

            if (!binding.isValid())
                bindingValue = Invalid;
            else if (binding.isNull())
                bindingValue = Orm::Constants::null_;
            else
                
                bindingValue = Helpers::qVariantTypeId(binding) == QMetaType::QString
                               ? Orm::Constants::TMPL_SQUOTES
                                 .arg(binding.template value<QString>())
                               : binding.template value<QString>();

            queryString.replace(queryString.indexOf(QLatin1Char('?')), 1, bindingValue);

            if (simpleBindings)

                simpleBindingsList << bindingValue;


#line 113 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"
        }

        return {std::move(queryString), std::move(simpleBindingsList)};
    }

} 



#line 123 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/utils/query.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"




namespace Orm::Tiny
{
    template<typename Model>
    class Builder;
}
#line 21 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"

namespace Orm::Query
{
    class JoinClause;

    
    template<typename T>
    concept Remove = std::convertible_to<T, quint64> ||
                     std::convertible_to<T, Query::Expression>;

    
    
    
    
    class __declspec(dllexport) Builder : public Concerns::BuildsQueries 
    {
        
        friend Concerns::BuildsQueries;

        
        template<typename Model>
        friend class Tiny::Builder;
#line 44 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"

        
        using QueryGrammar = Query::Grammars::Grammar;
        
        using QueryUtils = Orm::Utils::Query;

    public:
        
        Builder(std::shared_ptr<DatabaseConnection> connection,
                std::shared_ptr<QueryGrammar> grammar);
        

        
        inline ~Builder() override = default;

        
        inline Builder(const Builder &) = default;
        
        Builder &operator=(const Builder &) = delete;

        
        inline Builder(Builder &&) noexcept = default;
        
        Builder &operator=(Builder &&) = delete;

        
        
        SqlQuery get(const QVector<Column> &columns = {ASTERISK});
        
        SqlQuery find(const QVariant &id, const QVector<Column> &columns = {ASTERISK});

        
        SqlQuery findOr(const QVariant &id, const QVector<Column> &columns,
                        const std::function<void()> &callback);
        
        inline SqlQuery findOr(const QVariant &id,
                               const std::function<void()> &callback);

        
        template<typename R>
        std::pair<SqlQuery, R>
        findOr(const QVariant &id, const QVector<Column> &columns,
               const std::function<R()> &callback);
        
        template<typename R>
        std::pair<SqlQuery, R>
        findOr(const QVariant &id, const std::function<R()> &callback);

        
        SqlQuery first(const QVector<Column> &columns = {ASTERISK});
        
        QVariant value(const Column &column);
        

        QVariant soleValue(const Column &column);

        
        QVector<QVariant> pluck(const Column &column);
        

        template<typename T>
        std::map<T, QVariant> pluck(const Column &column, const Column &key);

        
        QString implode(const QString &column, const QString &glue = "");

        
        QString toSql();

        
        
        std::optional<SqlQuery>
        insert(const QVector<QVariantMap> &values);
        
        std::optional<SqlQuery>
        insert(const QVariantMap &values);
        
        std::optional<SqlQuery>
        insert(const QVector<QString> &columns, const QVector<QVector<QVariant>> &values);

        
        quint64 insertGetId(const QVariantMap &values, const QString &sequence = "");

        
        std::tuple<int, std::optional<QSqlQuery>>
        insertOrIgnore(const QVector<QVariantMap> &values);
        
        std::tuple<int, std::optional<QSqlQuery>>
        insertOrIgnore(const QVariantMap &values);
        
        std::tuple<int, std::optional<QSqlQuery>>
        insertOrIgnore(const QVector<QString> &columns,
                       const QVector<QVector<QVariant>> &values);

        
        std::tuple<int, QSqlQuery>
        update(const QVector<UpdateItem> &values);
        
        std::tuple<int, std::optional<QSqlQuery>>
        updateOrInsert(const QVector<WhereItem> &attributes,
                       const QVector<UpdateItem> &values);

        
        std::tuple<int, std::optional<QSqlQuery>>
        upsert(const QVector<QVariantMap> &values, const QStringList &uniqueBy,
               const QStringList &update);
        
        std::tuple<int, std::optional<QSqlQuery>>
        upsert(const QVector<QVariantMap> &values, const QStringList &uniqueBy);

        
        std::tuple<int, QSqlQuery> deleteRow();
        
        std::tuple<int, QSqlQuery> remove();
        
        template<Remove T>
        inline std::tuple<int, QSqlQuery> deleteRow(T &&id);
        
        template<Remove T>
        std::tuple<int, QSqlQuery> remove(T &&id);

        
        void truncate();

        
        
        inline quint64 count(const QVector<Column> &columns = {ASTERISK}) const;
        
        template<typename = void>
        inline quint64 count(const Column &column);
        
        inline QVariant min(const Column &column) const;
        
        inline QVariant max(const Column &column) const;
        
        inline QVariant sum(const Column &column) const;
        
        inline QVariant avg(const Column &column) const;
        
        inline QVariant average(const Column &column) const;

        
        QVariant aggregate(const QString &function,
                           const QVector<Column> &columns = {ASTERISK}) const;

        
        bool exists();
        
        inline bool doesntExist();

        
        bool existsOr(const std::function<void()> &callback);
        
        bool doesntExistOr(const std::function<void()> &callback);

        
        template<typename R>
        std::pair<bool, R> existsOr(const std::function<R()> &callback);
        template<typename R>
        
        std::pair<bool, R> doesntExistOr(const std::function<R()> &callback);

        
        Builder &select(const QVector<Column> &columns = {ASTERISK});
        
        Builder &select(const Column &column);
        
        Builder &addSelect(const QVector<Column> &columns);
        
        Builder &addSelect(const Column &column);

        
        Builder &select(QVector<Column> &&columns);
        
        Builder &select(Column &&column);
        
        Builder &addSelect(QVector<Column> &&columns);
        
        Builder &addSelect(Column &&column);

        
        template<Queryable T>
        inline Builder &select(T &&query, const QString &as);
        
        template<Queryable T>
        Builder &addSelect(T &&query, const QString &as);

        
        template<SubQuery T>
        Builder &selectSub(T &&query, const QString &as);
        
        Builder &selectRaw(const QString &expression,
                           const QVector<QVariant> &bindings = {});

        
        Builder &distinct();
        
        Builder &distinct(const QStringList &columns);
        
        Builder &distinct(QStringList &&columns);

        
        Builder &from(const QString &table, const QString &as = "");
        
        Builder &from(const Expression &table);
        
        Builder &from(Expression &&table);

        
        template<SubQuery T>
        Builder &fromSub(T &&query, const QString &as);
        
        Builder &fromRaw(const QString &expression,
                         const QVector<QVariant> &bindings = {});

        
        
        template<JoinTable T>
        inline Builder &
        join(T &&table, const QString &first, const QString &comparison,
             const QVariant &second, const QString &type = INNER, bool where = false);
        
        template<JoinTable T>
        inline Builder &
        join(T &&table, const std::function<void(JoinClause &)> &callback,
             const QString &type = INNER);
        
        template<JoinTable T>
        inline Builder &
        joinWhere(T &&table, const QString &first, const QString &comparison,
                  const QVariant &second, const QString &type = INNER);

        
        template<JoinTable T>
        inline Builder &
        leftJoin(T &&table, const QString &first, const QString &comparison,
                 const QVariant &second);
        
        template<JoinTable T>
        inline Builder &
        leftJoin(T &&table, const std::function<void(JoinClause &)> &callback);
        
        template<JoinTable T>
        inline Builder &
        leftJoinWhere(T &&table, const QString &first, const QString &comparison,
                      const QVariant &second);

        
        template<JoinTable T>
        inline Builder &
        rightJoin(T &&table, const QString &first, const QString &comparison,
                  const QVariant &second);
        
        template<JoinTable T>
        inline Builder &
        rightJoin(T &&table, const std::function<void(JoinClause &)> &callback);
        
        template<JoinTable T>
        inline Builder &
        rightJoinWhere(T &&table, const QString &first, const QString &comparison,
                       const QVariant &second);

        
        template<JoinTable T>
        inline Builder &
        crossJoin(T &&table, const QString &first, const QString &comparison,
                  const QVariant &second);
        
        template<JoinTable T>
        inline Builder &
        crossJoin(T &&table, const std::function<void(JoinClause &)> &callback);
        
        template<JoinTable T>
        inline Builder &crossJoin(T &&table);

        
        template<SubQuery T>
        inline Builder &
        joinSub(T &&query, const QString &as, const QString &first,
                const QString &comparison, const QVariant &second,
                const QString &type = INNER, bool where = false);
        
        template<SubQuery T>
        inline Builder &
        joinSub(T &&query, const QString &as,
                const std::function<void(JoinClause &)> &callback,
                const QString &type = INNER);

        
        template<SubQuery T>
        inline Builder &
        leftJoinSub(T &&query, const QString &as, const QString &first,
                    const QString &comparison, const QVariant &second);
        
        template<SubQuery T>
        inline Builder &
        leftJoinSub(T &&query, const QString &as,
                    const std::function<void(JoinClause &)> &callback);

        
        template<SubQuery T>
        inline Builder &
        rightJoinSub(T &&query, const QString &as, const QString &first,
                     const QString &comparison, const QVariant &second);
        
        template<SubQuery T>
        inline Builder &
        rightJoinSub(T &&query, const QString &as,
                     const std::function<void(JoinClause &)> &callback);

        
        
        template<WhereValue T>
        Builder &where(const Column &column, const QString &comparison,
                       T &&value, const QString &condition = AND);
        
        template<WhereValue T>
        Builder &orWhere(const Column &column, const QString &comparison, T &&value);
        
        template<WhereValue T>
        Builder &whereEq(const Column &column, T &&value,
                         const QString &condition = AND);
        
        template<WhereValue T>
        Builder &orWhereEq(const Column &column, T &&value);

        
        
        template<WhereValue T>
        Builder &whereNot(const Column &column, const QString &comparison,
                          T &&value, const QString &condition = AND);
        
        template<WhereValue T>
        Builder &orWhereNot(const Column &column, const QString &comparison, T &&value);
        
        template<WhereValue T>
        Builder &whereNotEq(const Column &column, T &&value,
                            const QString &condition = AND);
        
        template<WhereValue T>
        Builder &orWhereNotEq(const Column &column, T &&value);

        
        
        Builder &where(const std::function<void(Builder &)> &callback,
                       const QString &condition = AND);
        
        Builder &orWhere(const std::function<void(Builder &)> &callback);
        
        Builder &whereNot(const std::function<void(Builder &)> &callback,
                          const QString &condition = AND);
        
        Builder &orWhereNot(const std::function<void(Builder &)> &callback);

        
        
        Builder &where(const QVector<WhereItem> &values,
                       const QString &condition = AND,
                       const QString &defaultCondition = "");
        
        Builder &orWhere(const QVector<WhereItem> &values,
                         const QString &defaultCondition = "");
        
        Builder &whereNot(const QVector<WhereItem> &values,
                          const QString &condition = AND,
                          const QString &defaultCondition = "");
        
        Builder &orWhereNot(const QVector<WhereItem> &values,
                            const QString &defaultCondition = "");

        
        
        Builder &whereColumn(const QVector<WhereColumnItem> &values,
                             const QString &condition = AND);
        
        Builder &orWhereColumn(const QVector<WhereColumnItem> &values);

        
        Builder &whereColumn(const Column &first, const QString &comparison,
                             const Column &second, const QString &condition = AND);
        
        Builder &orWhereColumn(const Column &first, const QString &comparison,
                               const Column &second);
        
        Builder &whereColumnEq(const Column &first, const Column &second,
                               const QString &condition = AND);
        
        Builder &orWhereColumnEq(const Column &first, const Column &second);

        
        
        Builder &whereIn(const Column &column, const QVector<QVariant> &values,
                         const QString &condition = AND, bool nope = false);
        
        Builder &orWhereIn(const Column &column, const QVector<QVariant> &values);
        
        Builder &whereNotIn(const Column &column, const QVector<QVariant> &values,
                            const QString &condition = AND);
        
        Builder &orWhereNotIn(const Column &column, const QVector<QVariant> &values);

        
        
        Builder &whereNull(const QVector<Column> &columns = {ASTERISK},
                           const QString &condition = AND, bool nope = false);
        
        Builder &orWhereNull(const QVector<Column> &columns = {ASTERISK});
        
        Builder &whereNotNull(const QVector<Column> &columns = {ASTERISK},
                              const QString &condition = AND);
        
        Builder &orWhereNotNull(const QVector<Column> &columns = {ASTERISK});

        
        Builder &whereNull(const Column &column, const QString &condition = AND,
                           bool nope = false);
        
        Builder &orWhereNull(const Column &column);
        
        Builder &whereNotNull(const Column &column, const QString &condition = AND);
        
        Builder &orWhereNotNull(const Column &column);

        
        
        Builder &whereBetween(const Column &column, const WhereBetweenItem &values,
                              const QString &condition = AND, bool nope = false);
        
        Builder &orWhereBetween(const Column &column, const WhereBetweenItem &values);
        
        Builder &whereNotBetween(const Column &column, const WhereBetweenItem &values,
                                 const QString &condition = AND);
        
        Builder &orWhereNotBetween(const Column &column, const WhereBetweenItem &values);

        
        
        Builder &whereBetweenColumns(
                const Column &column, const WhereBetweenColumnsItem &betweenColumns,
                const QString &condition = AND, bool nope = false);
        
        Builder &orWhereBetweenColumns(
                const Column &column, const WhereBetweenColumnsItem &betweenColumns);
        
        Builder &whereNotBetweenColumns(
                const Column &column, const WhereBetweenColumnsItem &betweenColumns,
                const QString &condition = AND);
        
        Builder &orWhereNotBetweenColumns(
                const Column &column, const WhereBetweenColumnsItem &betweenColumns);

        
        
        template<Queryable C, WhereValue V>
        Builder &where(C &&column, const QString &comparison, V &&value,
                       const QString &condition = AND);
        
        template<Queryable C, WhereValue V>
        inline Builder &orWhere(C &&column, const QString &comparison, V &&value);
        
        template<Queryable C, WhereValue V>
        inline Builder &whereEq(C &&column, V &&value, const QString &condition = AND);
        
        template<Queryable C, WhereValue V>
        inline Builder &orWhereEq(C &&column, V &&value);

        
        
        template<Queryable C, WhereValue V>
        Builder &whereNot(C &&column, const QString &comparison, V &&value,
                          const QString &condition = AND);
        
        template<Queryable C, WhereValue V>
        inline Builder &orWhereNot(C &&column, const QString &comparison, V &&value);
        

        template<Queryable C, WhereValue V>
        inline Builder &whereNotEq(C &&column, V &&value, const QString &condition = AND);
        

        template<Queryable C, WhereValue V>
        inline Builder &orWhereNotEq(C &&column, V &&value);

        
        template<WhereValueSubQuery T>
        Builder &whereSub(const Column &column, const QString &comparison, T &&query,
                          const QString &condition = AND);

        
        
        template<QueryableShared C>
        Builder &whereExists(C &&callback, const QString &condition = AND,
                             bool nope = false);
        
        template<QueryableShared C>
        Builder &orWhereExists(C &&callback, bool nope = false);
        
        template<QueryableShared C>
        Builder &whereNotExists(C &&callback, const QString &condition = AND);
        
        template<QueryableShared C>
        Builder &orWhereNotExists(C &&callback);

        
        
        Builder &
        whereRowValues(const QVector<Column> &columns, const QString &comparison,
                       const QVector<QVariant> &values, const QString &condition = AND);
        
        Builder &
        orWhereRowValues(const QVector<Column> &columns, const QString &comparison,
                         const QVector<QVariant> &values);
        Builder &
        whereRowValuesEq(const QVector<Column> &columns, const QVector<QVariant> &values,
                         const QString &condition = AND);
        
        Builder &
        orWhereRowValuesEq(const QVector<Column> &columns,
                           const QVector<QVariant> &values);

        
        
        Builder &whereDate(const Column &column, const QString &comparison,
                           QVariant value, const QString &condition = AND);
        
        Builder &whereTime(const Column &column, const QString &comparison,
                           QVariant value, const QString &condition = AND);
        
        Builder &whereDay(const Column &column, const QString &comparison,
                          QVariant value, const QString &condition = AND);
        
        Builder &whereMonth(const Column &column, const QString &comparison,
                            QVariant value, const QString &condition = AND);
        
        Builder &whereYear(const Column &column, const QString &comparison,
                           QVariant value, const QString &condition = AND);

        
        inline Builder &whereEqDate(const Column &column, QVariant value,
                                    const QString &condition = AND);
        
        inline Builder &whereEqTime(const Column &column, QVariant value,
                                    const QString &condition = AND);
        
        inline Builder &whereEqDay(const Column &column, QVariant value,
                                   const QString &condition = AND);
        
        inline Builder &whereEqMonth(const Column &column, QVariant value,
                                     const QString &condition = AND);
        
        inline Builder &whereEqYear(const Column &column, QVariant value,
                                    const QString &condition = AND);

        
        inline Builder &orWhereDate(const Column &column, const QString &comparison,
                                    QVariant value);
        
        inline Builder &orWhereTime(const Column &column, const QString &comparison,
                                    QVariant value);
        
        inline Builder &orWhereDay(const Column &column, const QString &comparison,
                                   QVariant value);
        
        inline Builder &orWhereMonth(const Column &column, const QString &comparison,
                                     QVariant value);
        
        inline Builder &orWhereYear(const Column &column, const QString &comparison,
                                    QVariant value);

        
        
        Builder &whereRaw(const QString &sql, const QVector<QVariant> &bindings = {},
                          const QString &condition = AND);
        
        Builder &orWhereRaw(const QString &sql, const QVector<QVariant> &bindings = {});

        
        
        Builder &groupBy(const QVector<Column> &groups);
        
        Builder &groupBy(const Column &group);
        
        template<ColumnConcept ...Args>
        inline Builder &groupBy(Args &&...groups);

        
        Builder &groupByRaw(const QString &sql, const QVector<QVariant> &bindings = {});

        
        Builder &having(const Column &column, const QString &comparison,
                        const QVariant &value, const QString &condition = AND);
        
        Builder &orHaving(const Column &column, const QString &comparison,
                          const QVariant &value);

        
        Builder &havingRaw(const QString &sql, const QVector<QVariant> &bindings = {},
                           const QString &condition = AND);
        
        Builder &orHavingRaw(const QString &sql, const QVector<QVariant> &bindings = {});

        
        
        Builder &orderBy(const Column &column, const QString &direction = ASC);
        
        Builder &orderByDesc(const Column &column);

        
        template<Queryable T>
        Builder &orderBy(T &&query, const QString &direction = ASC);
        
        template<Queryable T>
        inline Builder &orderByDesc(T &&query);

        
        Builder &inRandomOrder(const QString &seed = "");
        
        Builder &orderByRaw(const QString &sql, const QVector<QVariant> &bindings = {});

        
        Builder &latest(const Column &column = CREATED_AT);
        
        Builder &oldest(const Column &column = CREATED_AT);
        
        Builder &reorder();
        
        Builder &reorder(const Column &column, const QString &direction = ASC);

        
        Builder &limit(qint64 value);
        
        Builder &take(qint64 value);
        
        Builder &offset(qint64 value);
        
        Builder &skip(qint64 value);
        
        Builder &forPage(qint64 page, qint64 perPage = 30);

        
        Builder &forPageBeforeId(qint64 perPage = 30, const QVariant &lastId = {},
                                 const QString &column = Orm::Constants::ID,
                                 bool prependOrder = false);
        
        Builder &forPageAfterId(qint64 perPage = 30, const QVariant &lastId = {},
                                const QString &column = Orm::Constants::ID,
                                bool prependOrder = false);

        
        
        template<typename T = std::size_t> requires std::is_arithmetic_v<T>
        std::tuple<int, QSqlQuery>
        increment(const QString &column, T amount = 1,
                  const QVector<UpdateItem> &extra = {});
        
        template<typename T = std::size_t> requires std::is_arithmetic_v<T>
        std::tuple<int, QSqlQuery>
        decrement(const QString &column, T amount = 1,
                  const QVector<UpdateItem> &extra = {});

        
        
        Builder &lockForUpdate();
        
        Builder &sharedLock();
        
        Builder &lock(bool value = true);
        
        Builder &lock(const char *value);
        
        Builder &lock(const QString &value);
        
        Builder &lock(QString &&value);

        
        
        void dump(bool replaceBindings = true, bool simpleBindings = false);
        
        void dd(bool replaceBindings = true, bool simpleBindings = false);

        
        
        const QString &defaultKeyName() const noexcept;
        
        inline DatabaseConnection &getConnection() const noexcept;
        
        inline const QueryGrammar &getGrammar() const noexcept;

        
        inline std::shared_ptr<DatabaseConnection> getConnectionShared() const noexcept;
        
        inline std::shared_ptr<QueryGrammar> getGrammarShared() const noexcept;

        
        QVector<QVariant> getBindings() const;
        
        inline const BindingsMap &getRawBindings() const noexcept;
        
        Builder &addBinding(const QVariant &binding,
                            BindingType type = BindingType::WHERE);
        
        Builder &addBinding(QVariant &&binding,
                            BindingType type = BindingType::WHERE);
        
        Builder &addBinding(const QVector<QVariant> &bindings,
                            BindingType type = BindingType::WHERE);
        
        Builder &addBinding(QVector<QVariant> &&bindings,
                            BindingType type = BindingType::WHERE);
        
        Builder &setBindings(QVector<QVariant> &&bindings,
                             BindingType type = BindingType::WHERE);

        
        inline const std::optional<AggregateItem> &getAggregate() const noexcept;
        
        inline const std::variant<bool, QStringList> &getDistinct() const noexcept;
        
        template<typename T> requires std::same_as<T, bool>
        inline bool getDistinct() const;
        
        template<typename T> requires std::same_as<T, QStringList>
        inline const QStringList &getDistinct() const;
        
        
        inline const QVector<Column> &getColumns() const noexcept;
        
        inline Builder &setColumns(const QVector<Column> &columns) noexcept;
        
        inline Builder &setColumns(QVector<Column> &&columns) noexcept;
        
        inline const FromClause &getFrom() const noexcept;
        
        inline const QVector<std::shared_ptr<JoinClause>> &getJoins() const noexcept;
        
        inline const QVector<WhereConditionItem> &getWheres() const noexcept;
        
        inline const QVector<Column> &getGroups() const noexcept;
        
        inline const QVector<HavingConditionItem> &getHavings() const noexcept;
        
        inline const QVector<OrderByItem> &getOrders() const noexcept;
        
        inline qint64 getLimit() const noexcept;
        
        inline qint64 getOffset() const noexcept;
        
        inline const std::variant<std::monostate, bool, QString> &
        getLock() const noexcept;

        
        
        virtual std::shared_ptr<Builder> newQuery() const;
        
        std::shared_ptr<Builder> forNestedWhere() const;

        
        Expression raw(const QVariant &value) const;
        
        Expression raw(QVariant &&value) const noexcept;

        
        Builder &addNestedWhereQuery(const std::shared_ptr<Builder> &query,
                                     const QString &condition);
        
        Builder &addWhereExistsQuery(const std::shared_ptr<Builder> &query,
                                     const QString &condition = AND, bool nope = false);
        
        Builder &addWhereExistsQuery(Builder &query, const QString &condition = AND,
                                     bool nope = false);

        
        Builder &mergeWheres(const QVector<WhereConditionItem> &wheres,
                             const QVector<QVariant> &bindings);
        
        Builder &mergeWheres(QVector<WhereConditionItem> &&wheres,
                             QVector<QVariant> &&bindings);

        
        enum struct PropertyType
        {
            COLUMNS,
        };

        
        inline Builder clone() const;
        
        Builder cloneWithout(const std::unordered_set<PropertyType> &properties) const;
        
        Builder cloneWithoutBindings(
                const std::unordered_set<BindingType> &except) const;

    protected:
        
        void throwIfInvalidOperator(const QString &comparison) const;

        
        static QVector<QVariant> cleanBindings(const QVector<QVariant> &bindings);
        
        static QVector<QVariant> cleanBindings(QVector<QVariant> &&bindings);
        
        static QVector<QVariant> cleanBindings(const WhereBetweenItem &bindings);

        
        Builder &
        addArrayOfWheres(const QVector<WhereItem> &values,
                         const QString &condition = AND,
                         const QString &defaultCondition = "");
        
        Builder &
        addArrayOfWheres(const QVector<WhereColumnItem> &values,
                         const QString &condition = AND);

        
        static std::shared_ptr<JoinClause>
        newJoinClause(const Builder &query, const QString &type, const QString &table);
        
        static std::shared_ptr<JoinClause>
        newJoinClause(const Builder &query, const QString &type, Expression &&table);

        
        Builder &clearColumns();
        
        SqlQuery
        onceWithColumns(const QVector<Column> &columns,
                        const std::function<SqlQuery()> &callback);

        
        std::pair<QString, QVector<QVariant>>
        createSub(const std::function<void(Builder &)> &callback) const;
        
        std::pair<QString, QVector<QVariant>>
        createSub(Builder &query) const;
        
        static std::pair<QString, QVector<QVariant>>
        createSub(const QString &query) noexcept;
        
        static std::pair<QString, QVector<QVariant>>
        createSub(QString &&query) noexcept;

        
        template<typename T>
        constexpr static bool isQueryable =
                std::is_convertible_v<T, Orm::QueryBuilder &> ||
                std::is_invocable_v<T, Orm::QueryBuilder &>;

        
        inline virtual std::shared_ptr<Builder> forSubQuery() const;

        
        Builder &prependDatabaseNameIfCrossDatabaseQuery(Builder &query) const;

        
        void enforceOrderBy() const;
        
        QVector<OrderByItem> removeExistingOrdersFor(const QString &column) const;

        
        static QString stripTableForPluck(const Column &column);

        
        
        Builder &setAggregate(const QString &function,
                              const QVector<Column> &columns = {ASTERISK});

    private:
        
        SqlQuery runSelect();

        
        inline Builder &setFrom(const FromClause &from);

        
        Builder &joinInternal(
                std::shared_ptr<JoinClause> &&join, const QString &first,
                const QString &comparison, const QVariant &second, bool where);
        
        Builder &joinInternal(
                std::shared_ptr<JoinClause> &&join,
                const std::function<void(JoinClause &)> &callback);
        
        Builder &joinInternal(std::shared_ptr<JoinClause> &&join);

        
        Builder &joinSubInternal(
                std::pair<QString, QVector<QVariant>> &&subQuery, const QString &as,
                const QString &first, const QString &comparison, const QVariant &second,
                const QString &type, bool where);
        
        Builder &joinSubInternal(
                std::pair<QString, QVector<QVariant>> &&subQuery, const QString &as,
                const std::function<void(JoinClause &)> &callback,
                const QString &type);

        
        Builder &whereInternal(
                const Column &column, const QString &comparison, QVariant value,
                const QString &condition, WhereType type = WhereType::BASIC);

        
        void checkBindingType(BindingType type) const;

        
        static const std::unordered_set<QString> &getOperators();

        
        std::shared_ptr<DatabaseConnection> m_connection;
        
        std::shared_ptr<QueryGrammar> m_grammar;

        

        BindingsMap m_bindings {
            {BindingType::SELECT,     {}},
            {BindingType::FROM,       {}},
            {BindingType::JOIN,       {}},
            {BindingType::WHERE,      {}},
            {BindingType::GROUPBY,    {}},
            {BindingType::HAVING,     {}},
            {BindingType::ORDER,      {}},
            {BindingType::UNION,      {}},
            {BindingType::UNIONORDER, {}},
        };

        
        std::optional<AggregateItem> m_aggregate = std::nullopt;
        
        std::variant<bool, QStringList> m_distinct = false;
        
        QVector<Column> m_columns {};
        
        FromClause m_from {};
        
        QVector<std::shared_ptr<JoinClause>> m_joins {};
        
        QVector<WhereConditionItem> m_wheres {};
        
        QVector<Column> m_groups {};
        
        QVector<HavingConditionItem> m_havings {};
        
        QVector<OrderByItem> m_orders {};
        
        qint64 m_limit = -1;
        
        qint64 m_offset = -1;
        
        std::variant<std::monostate, bool, QString> m_lock {};
    };

    

    

    SqlQuery Builder::findOr(const QVariant &id,
                             const std::function<void()> &callback)
    {
        return findOr(id, {ASTERISK}, callback);
    }

    template<typename R>
    std::pair<SqlQuery, R>
    Builder::findOr(const QVariant &id, const QVector<Column> &columns,
                    const std::function<R()> &callback)
    {
        auto query = find(id, columns);

        if (query.isValid())
            return {std::move(query), R {}};

        



        
        if (callback)
            return {std::move(query), std::invoke(callback)};

        return {std::move(query), R {}};
    }

    template<typename R>
    std::pair<SqlQuery, R>
    Builder::findOr(const QVariant &id, const std::function<R()> &callback)
    {
        return findOr<R>(id, {ASTERISK}, callback);
    }

    template<typename T>
    std::map<T, QVariant>
    Builder::pluck(const Column &column, const Column &key)
    {
        


        auto query = get({column, key});

        
        if (QueryUtils::queryResultSize(query) == 0)
            return {};

        


        const auto unqualifiedColumn = stripTableForPluck(column);

        const auto unqualifiedKey = stripTableForPluck(key);

        std::map<T, QVariant> result;

        while (query.next())
            result.try_emplace(query.value(unqualifiedKey).value<T>(),
                               query.value(unqualifiedColumn));

        return result;
    }

    

    template<Remove T>
    std::tuple<int, QSqlQuery> Builder::deleteRow(T &&id)
    {
        return remove(std::forward<T>(id));
    }

    template<Remove T>
    std::tuple<int, QSqlQuery> Builder::remove(T &&id)
    {
        



        where(([]() noexcept -> QString { enum { Size = sizeof(u"" "%1.id")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "%1.id" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()).arg(std::get<QString>(m_from)), EQ,
              std::forward<T>(id), AND);

        return remove();
    }

    

    quint64 Builder::count(const QVector<Column> &columns) const
    {
        return aggregate(([]() noexcept -> QString { enum { Size = sizeof(u"" "count")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "count" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()), columns).template value<quint64>();
    }

    template<typename>
    quint64 Builder::count(const Column &column)
    {
        return aggregate(([]() noexcept -> QString { enum { Size = sizeof(u"" "count")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "count" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()), {column}).template value<quint64>();
    }

    QVariant Builder::min(const Column &column) const
    {
        return aggregate(([]() noexcept -> QString { enum { Size = sizeof(u"" "min")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "min" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()), {column});
    }

    QVariant Builder::max(const Column &column) const
    {
        return aggregate(([]() noexcept -> QString { enum { Size = sizeof(u"" "max")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "max" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()), {column});
    }

    QVariant Builder::sum(const Column &column) const
    {
        auto result = aggregate(([]() noexcept -> QString { enum { Size = sizeof(u"" "sum")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "sum" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()), {column});

        if (!result.isValid() || result.isNull())
            result = 0;

        return result;
    }

    QVariant Builder::avg(const Column &column) const
    {
        return aggregate(([]() noexcept -> QString { enum { Size = sizeof(u"" "avg")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "avg" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()), {column});
    }

    QVariant Builder::average(const Column &column) const
    {
        return avg(column);
    }

    bool Builder::doesntExist()
    {
        return !exists();
    }

    template<typename R>
    std::pair<bool, R> Builder::existsOr(const std::function<R()> &callback)
    {
        if (exists())
            return {true, R {}};

        return {false, std::invoke(callback)};
    }

    template<typename R>
    std::pair<bool, R> Builder::doesntExistOr(const std::function<R()> &callback)
    {
        if (doesntExist())
            return {true, R {}};

        return {false, std::invoke(callback)};
    }

    template<Queryable T>
    Builder &Builder::select(T &&query, const QString &as)
    {
        return selectSub(std::forward<T>(query), as);
    }

    template<Queryable T>
    Builder &Builder::addSelect(T &&query, const QString &as)
    {
        if (m_columns.isEmpty())
            select(QVector<Column> {([]() noexcept -> QString { enum { Size = sizeof(u"" "%1.*")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "%1.*" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }())
                                    .arg(std::get<QString>(m_from))});

        return selectSub(std::forward<T>(query), as);
    }

    template<SubQuery T>
    Builder &Builder::selectSub(T &&query, const QString &as)
    {
        const auto [queryString, bindings] = createSub(std::forward<T>(query));

        return selectRaw(([]() noexcept -> QString { enum { Size = sizeof(u"" "(%1) as %2")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "(%1) as %2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()).arg(queryString,
                                                          m_grammar->wrap(as)),
                         bindings);
    }

    template<SubQuery T>
    Builder &
    Builder::fromSub(T &&query, const QString &as)
    {
        const auto [queryString, bindings] = createSub(std::forward<T>(query));

        return fromRaw(([]() noexcept -> QString { enum { Size = sizeof(u"" "(%1) as %2")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "(%1) as %2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()).arg(queryString,
                                                        m_grammar->wrapTable(as)),
                       bindings);
    }

    

    template<JoinTable T>
    Builder &
    Builder::join(T &&table, const QString &first, const QString &comparison,
                  const QVariant &second, const QString &type, const bool where)
    {
        
        return joinInternal(newJoinClause(*this, type, std::forward<T>(table)),
                            first, comparison, second, where);
    }

    
    template<JoinTable T>
    Builder &
    Builder::join(T &&table, const std::function<void(JoinClause &)> &callback,
                  const QString &type)
    {
        
        return joinInternal(newJoinClause(*this, type, std::forward<T>(table)),
                            callback);
    }

    template<JoinTable T>
    Builder &
    Builder::joinWhere(T &&table, const QString &first, const QString &comparison,
                       const QVariant &second, const QString &type)
    {
        return join(std::forward<T>(table), first, comparison, second, type, true);
    }

    template<JoinTable T>
    Builder &
    Builder::leftJoin(T &&table, const QString &first, const QString &comparison,
                      const QVariant &second)
    {
        return join(std::forward<T>(table), first, comparison, second, LEFT);
    }

    template<JoinTable T>
    Builder &
    Builder::leftJoin(T &&table, const std::function<void(JoinClause &)> &callback)
    {
        return join(std::forward<T>(table), callback, LEFT);
    }

    template<JoinTable T>
    Builder &
    Builder::leftJoinWhere(T &&table, const QString &first, const QString &comparison,
                           const QVariant &second)
    {
        return joinWhere(std::forward<T>(table), first, comparison, second, LEFT);
    }

    template<JoinTable T>
    Builder &
    Builder::rightJoin(T &&table, const QString &first, const QString &comparison,
                       const QVariant &second)
    {
        return join(std::forward<T>(table), first, comparison, second, RIGHT);
    }

    template<JoinTable T>
    Builder &
    Builder::rightJoin(T &&table, const std::function<void(JoinClause &)> &callback)
    {
        return join(std::forward<T>(table), callback, RIGHT);
    }

    template<JoinTable T>
    Builder &
    Builder::rightJoinWhere(T &&table, const QString &first, const QString &comparison,
                            const QVariant &second)
    {
        return joinWhere(std::forward<T>(table), first, comparison, second, RIGHT);
    }

    
    
    template<JoinTable T>
    Builder &
    Builder::crossJoin(T &&table, const QString &first, const QString &comparison,
                       const QVariant &second)
    {
        return join(std::forward<T>(table), first, comparison, second, CROSS);
    }

    template<JoinTable T>
    Builder &
    Builder::crossJoin(T &&table, const std::function<void(JoinClause &)> &callback)
    {
        return join(std::forward<T>(table), callback, CROSS);
    }

    template<JoinTable T>
    Builder &
    Builder::crossJoin(T &&table)
    {
        
        m_joins << newJoinClause(*this, CROSS, std::forward<T>(table));

        return *this;
    }

    template<SubQuery T>
    Builder &
    Builder::joinSub(T &&query, const QString &as, const QString &first,
                     const QString &comparison, const QVariant &second,
                     const QString &type, const bool where)
    {
        return joinSubInternal(createSub(std::forward<T>(query)),
                               as, first, comparison, second, type, where);
    }

    template<SubQuery T>
    Builder &
    Builder::joinSub(T &&query, const QString &as,
                     const std::function<void(JoinClause &)> &callback,
                     const QString &type)
    {
        return joinSubInternal(createSub(std::forward<T>(query)), as, callback, type);
    }

    template<SubQuery T>
    Builder &
    Builder::leftJoinSub(T &&query, const QString &as, const QString &first,
                         const QString &comparison, const QVariant &second)
    {
        return joinSub(std::forward<T>(query), as, first, comparison, second, LEFT);
    }

    template<SubQuery T>
    Builder &
    Builder::leftJoinSub(T &&query, const QString &as,
                         const std::function<void(JoinClause &)> &callback)
    {
        return joinSub(std::forward<T>(query), as, callback, LEFT);
    }

    template<SubQuery T>
    Builder &
    Builder::rightJoinSub(T &&query, const QString &as, const QString &first,
                          const QString &comparison, const QVariant &second)
    {
        return joinSub(std::forward<T>(query), as, first, comparison, second, RIGHT);
    }

    template<SubQuery T>
    Builder &
    Builder::rightJoinSub(T &&query, const QString &as,
                          const std::function<void(JoinClause &)> &callback)
    {
        return joinSub(std::forward<T>(query), as, callback, RIGHT);
    }

    

    template<WhereValue T>
    Builder &
    Builder::where(const Column &column, const QString &comparison, T &&value,
                   const QString &condition)
    {
        


        if constexpr (isQueryable<T>)
            return whereSub(column, comparison, std::forward<T>(value), condition);
        else
            return whereInternal(column, comparison, std::forward<T>(value), condition);
    }

    template<WhereValue T>
    Builder &
    Builder::orWhere(const Column &column, const QString &comparison, T &&value)
    {
        return where(column, comparison, std::forward<T>(value), OR);
    }

    template<WhereValue T>
    Builder &
    Builder::whereEq(const Column &column, T &&value, const QString &condition)
    {
        return where(column, EQ, std::forward<T>(value), condition);
    }

    template<WhereValue T>
    Builder &Builder::orWhereEq(const Column &column, T &&value)
    {
        return where(column, EQ, std::forward<T>(value), OR);
    }

    

    template<WhereValue T>
    Builder &
    Builder::whereNot(const Column &column, const QString &comparison, T &&value,
                      const QString &condition)
    {
        return where(column, comparison, std::forward<T>(value),
                     SPACE_IN.arg(condition, NOT));
    }

    template<WhereValue T>
    Builder &
    Builder::orWhereNot(const Column &column, const QString &comparison, T &&value)
    {
        return where(column, comparison, std::forward<T>(value),
                     SPACE_IN.arg(OR, NOT));
    }

    template<WhereValue T>
    Builder &
    Builder::whereNotEq(const Column &column, T &&value, const QString &condition)
    {
        return where(column, EQ, std::forward<T>(value), SPACE_IN.arg(condition, NOT));
    }

    template<WhereValue T>
    Builder &Builder::orWhereNotEq(const Column &column, T &&value)
    {
        return where(column, EQ, std::forward<T>(value), SPACE_IN.arg(OR, NOT));
    }

    

    template<Queryable C, WhereValue V>
    Builder &
    Builder::where(C &&column, const QString &comparison, V &&value,
                   const QString &condition)
    {
        



        

        auto [queryString, bindings] = createSub(std::forward<C>(column));

        addBinding(std::move(bindings), BindingType::WHERE);

        return where(Expression(PARENTH_ONE.arg(queryString)), comparison,
                     std::forward<V>(value), condition);
    }

    template<Queryable C, WhereValue V>
    Builder &Builder::orWhere(C &&column, const QString &comparison, V &&value)
    {
        return where(std::forward<C>(column), comparison, std::forward<V>(value), OR);
    }

    template<Queryable C, WhereValue V>
    Builder &Builder::whereEq(C &&column, V &&value, const QString &condition)
    {
        return where(std::forward<C>(column), EQ, std::forward<V>(value), condition);
    }

    template<Queryable C, WhereValue V>
    Builder &Builder::orWhereEq(C &&column, V &&value)
    {
        return where(std::forward<C>(column), EQ, std::forward<V>(value), OR);
    }

    

    template<Queryable C, WhereValue V>
    Builder &
    Builder::whereNot(C &&column, const QString &comparison, V &&value,
                      const QString &condition)
    {
        return where(std::forward<C>(column), comparison, std::forward<V>(value),
                     SPACE_IN.arg(condition, NOT));
    }

    template<Queryable C, WhereValue V>
    Builder &Builder::orWhereNot(C &&column, const QString &comparison, V &&value)
    {
        return where(std::forward<C>(column), comparison, std::forward<V>(value),
                     SPACE_IN.arg(OR, NOT));
    }

    template<Queryable C, WhereValue V>
    Builder &Builder::whereNotEq(C &&column, V &&value, const QString &condition)
    {
        return where(std::forward<C>(column), EQ, std::forward<V>(value),
                     SPACE_IN.arg(condition, NOT));
    }

    template<Queryable C, WhereValue V>
    Builder &Builder::orWhereNotEq(C &&column, V &&value)
    {
        return where(std::forward<C>(column), EQ, std::forward<V>(value),
                     SPACE_IN.arg(OR, NOT));
    }

    template<WhereValueSubQuery T>
    Builder &
    Builder::whereSub(const Column &column, const QString &comparison,
                      T &&query, const QString &condition)
    {
        

        auto [queryString, bindings] = createSub(std::forward<T>(query));

        addBinding(std::move(bindings), BindingType::WHERE);

        return where(column, comparison, Expression(PARENTH_ONE.arg(queryString)),
                     condition);
    }

    

    template<QueryableShared C>
    Builder &Builder::whereExists(C &&callback, const QString &condition,
                                  const bool nope)
    {
        if constexpr (std::invocable<C, Builder &>) {
            
            const auto query = forSubQuery();

            


            std::invoke(callback, *query);

            return addWhereExistsQuery(query, condition, nope);
        }

        
        else
            return addWhereExistsQuery(callback, condition, nope);
    }

    template<QueryableShared C>
    Builder &Builder::orWhereExists(C &&callback, const bool nope)
    {
        return whereExists(callback, OR, nope);
    }

    template<QueryableShared C>
    Builder &Builder::whereNotExists(C &&callback, const QString &condition)
    {
        return whereExists(callback, condition, true);
    }

    template<QueryableShared C>
    Builder &Builder::orWhereNotExists(C &&callback)
    {
        return whereExists(callback, OR, true);
    }

    

    Builder &
    Builder::whereEqDate(const Column &column, QVariant value, const QString &condition)
    {
        return whereDate(column, EQ, std::move(value), condition);
    }

    Builder &
    Builder::whereEqTime(const Column &column, QVariant value, const QString &condition)
    {
        return whereTime(column, EQ, std::move(value), condition);
    }

    Builder &
    Builder::whereEqDay(const Column &column, QVariant value, const QString &condition)
    {
        return whereDay(column, EQ, std::move(value), condition);
    }

    Builder &
    Builder::whereEqMonth(const Column &column, QVariant value, const QString &condition)
    {
        return whereMonth(column, EQ, std::move(value), condition);
    }

    Builder &
    Builder::whereEqYear(const Column &column, QVariant value, const QString &condition)
    {
        return whereYear(column, EQ, std::move(value), condition);
    }

    Builder &
    Builder::orWhereDate(const Column &column, const QString &comparison, QVariant value)
    {
        return whereDate(column, comparison, std::move(value), OR);
    }

    Builder &
    Builder::orWhereTime(const Column &column, const QString &comparison, QVariant value)
    {
        return whereTime(column, comparison, std::move(value), OR);
    }

    Builder &
    Builder::orWhereDay(const Column &column, const QString &comparison, QVariant value)
    {
        return whereDay(column, comparison, std::move(value), OR);
    }

    Builder &
    Builder::orWhereMonth(const Column &column, const QString &comparison, QVariant value)
    {
        return whereMonth(column, comparison, std::move(value), OR);
    }

    Builder &
    Builder::orWhereYear(const Column &column, const QString &comparison, QVariant value)
    {
        return whereYear(column, comparison, std::move(value), OR);
    }

    template<ColumnConcept ...Args>
    Builder &Builder::groupBy(Args &&...groups)
    {
        return groupBy(QVector<Column> {std::forward<Args>(groups)...});
    }

    template<Queryable T>
    Builder &Builder::orderBy(T &&query, const QString &direction)
    {
        auto [queryString, bindings] = createSub(std::forward<T>(query));

        addBinding(std::move(bindings), BindingType::ORDER);

        return orderBy(Expression(PARENTH_ONE.arg(queryString)), direction);
    }

    template<Queryable T>
    Builder &Builder::orderByDesc(T &&query)
    {
        return orderBy(std::forward<T>(query), DESC);
    }

    

    template<typename T> requires std::is_arithmetic_v<T>
    std::tuple<int, QSqlQuery>
    Builder::increment(const QString &column, const T amount,
                       const QVector<UpdateItem> &extra)
    {
        const auto expression = ([]() noexcept -> QString { enum { Size = sizeof(u"" "%1 + %2")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "%1 + %2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()).arg(m_grammar->wrap(column))
                                .arg(amount);

        QVector<UpdateItem> columns {{column, raw(expression)}};
        std::copy(extra.cbegin(), extra.cend(), std::back_inserter(columns));

        return update(columns);
    }

    template<typename T> requires std::is_arithmetic_v<T>
    std::tuple<int, QSqlQuery>
    Builder::decrement(const QString &column, const T amount,
                       const QVector<UpdateItem> &extra)
    {
        const auto expression = ([]() noexcept -> QString { enum { Size = sizeof(u"" "%1 - %2")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "%1 - %2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()).arg(m_grammar->wrap(column))
                                .arg(amount);

        QVector<UpdateItem> columns {{column, raw(expression)}};
        std::copy(extra.cbegin(), extra.cend(), std::back_inserter(columns));

        return update(columns);
    }

    

    DatabaseConnection &Builder::getConnection() const noexcept
    {
        return *m_connection;
    }

    const Builder::QueryGrammar &Builder::getGrammar() const noexcept
    {
        return *m_grammar;
    }

    std::shared_ptr<DatabaseConnection> Builder::getConnectionShared() const noexcept
    {
        return m_connection;
    }

    std::shared_ptr<Builder::QueryGrammar> Builder::getGrammarShared() const noexcept
    {
        return m_grammar;
    }

    const BindingsMap &Builder::getRawBindings() const noexcept
    {
        return m_bindings;
    }

    const std::optional<AggregateItem> &Builder::getAggregate() const noexcept
    {
        return m_aggregate;
    }

    const std::variant<bool, QStringList> &Builder::getDistinct() const noexcept
    {
        return m_distinct;
    }

    template<typename T> requires std::same_as<T, bool>
    bool Builder::getDistinct() const
    {
        return std::get<bool>(m_distinct);
    }

    template<typename T> requires std::same_as<T, QStringList>
    const QStringList &
    Builder::getDistinct() const
    {
        return std::get<QStringList>(m_distinct);
    }

    const QVector<Column> &
    Builder::getColumns() const noexcept
    {
        return m_columns;
    }

    Builder &
    Builder::setColumns(const QVector<Column> &columns) noexcept
    {
        m_columns = columns;

        return *this;
    }

    Builder &
    Builder::setColumns(QVector<Column> &&columns) noexcept
    {
        m_columns = std::move(columns);

        return *this;
    }

    const FromClause &
    Builder::getFrom() const noexcept
    {
        return m_from;
    }

    const QVector<std::shared_ptr<JoinClause>> &
    Builder::getJoins() const noexcept
    {
        return m_joins;
    }

    const QVector<WhereConditionItem> &
    Builder::getWheres() const noexcept
    {
        return m_wheres;
    }

    const QVector<Column> &
    Builder::getGroups() const noexcept
    {
        return m_groups;
    }

    const QVector<HavingConditionItem> &
    Builder::getHavings() const noexcept
    {
        return m_havings;
    }

    const QVector<OrderByItem> &
    Builder::getOrders() const noexcept
    {
        return m_orders;
    }

    qint64 Builder::getLimit() const noexcept
    {
        return m_limit;
    }

    qint64 Builder::getOffset() const noexcept
    {
        return m_offset;
    }

    const std::variant<std::monostate, bool, QString> &
    Builder::getLock() const noexcept
    {
        return m_lock;
    }

    Builder Builder::clone() const
    {
        return *this;
    }

    

    std::shared_ptr<Builder>
    Builder::forSubQuery() const
    {
        return newQuery();
    }

    

    Builder &
    Builder::setFrom(const FromClause &from)
    {
        m_from = from;

        return *this;
    }

} 



#line 1801 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/querybuilder.hpp"
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconfiguration.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariantHash"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconfiguration.hpp"




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/threadlocal.hpp"
#pragma once




__pragma(system_header)









#line 25 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/threadlocal.hpp"



#line 29 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/threadlocal.hpp"

#line 31 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/macros/threadlocal.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconfiguration.hpp"



namespace Orm::Support
{

    
    class DatabaseConfiguration
    {
        DatabaseConfiguration(const DatabaseConfiguration &) = delete; DatabaseConfiguration &operator=(const DatabaseConfiguration &) = delete;

    public:
        
        using ConfigurationsType = std::unordered_map<QString, QVariantHash>;

        
        inline DatabaseConfiguration() = default;
        
        inline ~DatabaseConfiguration() = default;

        

        thread_local
        inline static QString defaultConnectionName = ([]() noexcept -> QString { enum { Size = sizeof(u"" "tinyorm_default")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "tinyorm_default" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }());

        
        thread_local
        inline static QString defaultConnection;

        
        thread_local
        inline static
        QString defaultSavepointNamespace = ([]() noexcept -> QString { enum { Size = sizeof(u"" "tinyorm_savepoint")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "tinyorm_savepoint" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }());

        
        inline ConfigurationsType *operator->() noexcept;
        
        inline const ConfigurationsType *operator->() const noexcept;
        
        inline ConfigurationsType &operator*() noexcept;
        
        inline const ConfigurationsType &operator*() const noexcept;
        
        inline ConfigurationsType &get() noexcept;
        
        inline const ConfigurationsType &get() const noexcept;

    private:
        
        thread_local
        inline static ConfigurationsType m_configurations;
    };

    

    DatabaseConfiguration::ConfigurationsType *
    DatabaseConfiguration::operator->() noexcept
    {
        return std::addressof(m_configurations);
    }

    const DatabaseConfiguration::ConfigurationsType *
    DatabaseConfiguration::operator->() const noexcept
    {
        return std::addressof(m_configurations);
    }

    DatabaseConfiguration::ConfigurationsType &
    DatabaseConfiguration::operator*() noexcept
    {
        return m_configurations;
    }

    const DatabaseConfiguration::ConfigurationsType &
    DatabaseConfiguration::operator*() const noexcept
    {
        return m_configurations;
    }

    DatabaseConfiguration::ConfigurationsType &
    DatabaseConfiguration::get() noexcept 
    {
        return m_configurations;
    }

    const DatabaseConfiguration::ConfigurationsType &
    DatabaseConfiguration::get() const noexcept 
    {
        return m_configurations;
    }

} 



#line 110 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconfiguration.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconnectionsmap.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/countsqueries.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QElapsedTimer"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qelapsedtimer.h"















































class __declspec(dllimport) QElapsedTimer
{
public:
    enum ClockType {
        SystemTime,
        MonotonicClock,
        TickCounter,
        MachAbsoluteTime,
        PerformanceCounter
    };

    constexpr QElapsedTimer()
        : t1(0x8000000000000000i64),
          t2(0x8000000000000000i64)
    {
    }

    static ClockType clockType() noexcept;
    static bool isMonotonic() noexcept;

    void start() noexcept;
    qint64 restart() noexcept;
    void invalidate() noexcept;
    bool isValid() const noexcept;

    qint64 nsecsElapsed() const noexcept;
    qint64 elapsed() const noexcept;
    bool hasExpired(qint64 timeout) const noexcept;

    qint64 msecsSinceReference() const noexcept;
    qint64 msecsTo(const QElapsedTimer &other) const noexcept;
    qint64 secsTo(const QElapsedTimer &other) const noexcept;

    bool operator==(const QElapsedTimer &other) const noexcept
    { return t1 == other.t1 && t2 == other.t2; }
    bool operator!=(const QElapsedTimer &other) const noexcept
    { return !(*this == other); }

    friend bool __declspec(dllimport) operator<(const QElapsedTimer &v1, const QElapsedTimer &v2) noexcept;

private:
    qint64 t1;
    qint64 t2;
};



#line 96 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qelapsedtimer.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QElapsedTimer"
#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/countsqueries.hpp"




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/statementscounter.hpp"
#pragma once




__pragma(system_header)





namespace Orm
{
namespace Types
{

    
    struct StatementsCounter
    {
        
        
        int normal = -1;
        
        int affecting = -1;
        
        int transactional = -1;
    };

} 

    using StatementsCounter = Types::StatementsCounter;

} 



#line 38 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/statementscounter.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/countsqueries.hpp"



namespace Orm
{

class DatabaseConnection;

namespace Concerns
{

    
    class __declspec(dllexport) CountsQueries
    {
        CountsQueries(const CountsQueries &) = delete; CountsQueries &operator=(const CountsQueries &) = delete;

        
        friend class ManagesTransactions;

    public:
        
        inline CountsQueries() = default;
        
        inline virtual ~CountsQueries() = 0;

        
        
        bool countingElapsed() const;
        
        DatabaseConnection &enableElapsedCounter();
        
        DatabaseConnection &disableElapsedCounter();
        
        qint64 getElapsedCounter() const;
        
        qint64 takeElapsedCounter();
        
        DatabaseConnection &resetElapsedCounter();

        
        
        bool countingStatements() const;
        
        DatabaseConnection &enableStatementsCounter();
        
        DatabaseConnection &disableStatementsCounter();
        
        const StatementsCounter &getStatementsCounter() const;
        
        StatementsCounter takeStatementsCounter();
        
        DatabaseConnection &resetStatementsCounter();

    protected:
        
        
        bool m_countingElapsed = false;
        
        qint64 m_elapsedCounter = -1;

        
        
        bool m_countingStatements = false;
        
        StatementsCounter m_statementsCounter {};

    private:
        
        std::optional<qint64>
        hitTransactionalCounters(QElapsedTimer timer, bool countElapsed);

        
        DatabaseConnection &databaseConnection();
    };

    

    CountsQueries::~CountsQueries() = default;

} 
} 



#line 99 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/countsqueries.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/detectslostconnections.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QtGlobal"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/detectslostconnections.hpp"




class QSqlError;



namespace Orm
{

namespace Exceptions
{
    class SqlError;
}

namespace Concerns
{

    
    class __declspec(dllexport) DetectsLostConnections
    {
        DetectsLostConnections(const DetectsLostConnections &) = delete; DetectsLostConnections &operator=(const DetectsLostConnections &) = delete;

    public:
        
        inline DetectsLostConnections() = default;
        
        inline virtual ~DetectsLostConnections() = 0;

        
        static bool causedByLostConnection(const Exceptions::SqlError &e);
        
        static bool causedByLostConnection(const QSqlError &e);
    };

    

    DetectsLostConnections::~DetectsLostConnections() = default;

} 
} 



#line 55 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/detectslostconnections.hpp"
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/logsqueries.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/QSqlQuery"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/logsqueries.hpp"







#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/log.hpp"
#pragma once



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 6 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/log.hpp"


__pragma(system_header)





namespace Orm
{
namespace Types
{

    
    struct Log
    {
        
        enum struct Type
        {
            UNDEFINED = -1,
            NORMAL,
            TRANSACTION,
        };

        
        QString query;
        
        QVector<QVariant> boundValues;
        
        Type type = Type::UNDEFINED;
        
        std::size_t order = 0;
        
        qint64 elapsed = -1;
        
        int results = -1;
        
        int affected = -1;
    };

} 

    using Log = Types::Log;

} 



#line 55 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/types/log.hpp"
#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/logsqueries.hpp"



namespace Orm
{

class DatabaseConnection;

namespace Concerns
{

    
    class __declspec(dllexport) LogsQueries
    {
        LogsQueries(const LogsQueries &) = delete; LogsQueries &operator=(const LogsQueries &) = delete;

    public:
        
        inline LogsQueries() = default;
        
        inline virtual ~LogsQueries() = 0;

        
        inline void logQuery(const QSqlQuery &query, std::optional<qint64> elapsed,
                             const QString &type) const;
        
        inline void logQuery(const std::tuple<int, QSqlQuery> &queryResult,
                             std::optional<qint64> elapsed, const QString &type) const;
        
        void logQueryForPretend(const QString &query,
                                const QVector<QVariant> &preparedBindings,
                                const QString &type) const;
        
        void logTransactionQuery(const QString &query,
                                 std::optional<qint64> elapsed) const;
        

        void logTransactionQueryForPretend(const QString &query) const;

        
        inline std::shared_ptr<QVector<Log>> getQueryLog() const noexcept;
        
        void flushQueryLog();
        
        void enableQueryLog();
        
        inline void disableQueryLog() noexcept;
        
        inline bool logging() const noexcept;
        
        inline static std::size_t getQueryLogOrder() noexcept;

        

        inline bool debugSql() const noexcept;
        
        inline void disableDebugSql() noexcept;
        
        inline void enableDebugSql() noexcept;

    protected:
        
        QVector<Log>
        withFreshQueryLog(const std::function<QVector<Log>()> &callback);

        
        bool m_recordsModified = false;
        
        std::shared_ptr<QVector<Log>> m_queryLog = nullptr;
        
        inline static std::atomic<std::size_t> m_queryLogId = 0;


        
        bool m_debugSql = true;



#line 96 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/logsqueries.hpp"

    private:
        
        void logQueryInternal(const QSqlQuery &query, std::optional<qint64> elapsed,
                              const QString &type) const;

        
        static QVector<QVariant>
        convertNamedToPositionalBindings(QVariantMap &&bindings);

        
        const DatabaseConnection &databaseConnection() const;

        
        bool m_loggingQueries = false;
        
        std::shared_ptr<QVector<Log>> m_queryLogForPretend = nullptr;
    };

    

    LogsQueries::~LogsQueries() = default;

    void LogsQueries::logQuery(
            const QSqlQuery &queryResult, std::optional<qint64> elapsed,
            const QString &type) const
    {
        logQueryInternal(queryResult, elapsed, type);
    }

    void LogsQueries::logQuery(
            const std::tuple<int, QSqlQuery> &queryResult,
            std::optional<qint64> elapsed, const QString &type) const
    {
        logQueryInternal(std::get<1>(queryResult), elapsed, type);
    }

    std::shared_ptr<QVector<Log>> LogsQueries::getQueryLog() const noexcept
    {
        return m_queryLog;
    }

    void LogsQueries::disableQueryLog() noexcept
    {
        m_loggingQueries = false;
    }

    bool LogsQueries::logging() const noexcept
    {
        return m_loggingQueries;
    }

    std::size_t LogsQueries::getQueryLogOrder() noexcept
    {
        return m_queryLogId;
    }

    bool LogsQueries::debugSql() const noexcept
    {
        return m_debugSql;
    }

    void LogsQueries::disableDebugSql() noexcept
    {
        m_debugSql = false;
    }

    void LogsQueries::enableDebugSql() noexcept
    {
        m_debugSql = true;
    }

} 
} 



#line 174 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/logsqueries.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/managestransactions.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/managestransactions.hpp"




class QSqlError;



namespace Orm
{

class DatabaseConnection;
class MySqlConnection;

namespace Concerns
{

    class CountsQueries;

    
    
    
    class __declspec(dllexport) ManagesTransactions
    {
        ManagesTransactions(const ManagesTransactions &) = delete; ManagesTransactions &operator=(const ManagesTransactions &) = delete;

        
        friend DatabaseConnection;
        
        friend MySqlConnection;

    public:
        
        ManagesTransactions();
        
        inline virtual ~ManagesTransactions() = 0;

        
        bool beginTransaction();
        
        bool commit();
        
        bool rollBack();
        
        bool savepoint(const QString &id);
        
        bool savepoint(std::size_t id);
        
        bool rollbackToSavepoint(const QString &id);
        
        bool rollbackToSavepoint(std::size_t id);
        
        inline std::size_t transactionLevel() const;

        
        inline bool inTransaction() const;

        
        inline const QString &getSavepointNamespace() const;
        
        DatabaseConnection &setSavepointNamespace(const QString &savepointNamespace);

    private:
        
        DatabaseConnection &resetTransactions();

        
        DatabaseConnection &databaseConnection();
        
        Concerns::CountsQueries &countsQueries();

        
        void handleStartTransactionError(
                const QString &functionName, const QString &queryString,
                QSqlError &&error);
        

        void handleCommonTransactionError(
                const QString &functionName, const QString &queryString,
                QSqlError &&error);

        

        [[noreturn]]
        static void throwIfTransactionError(
                const QString &functionName, const QString &queryString,
                QSqlError &&error);

        
        bool m_inTransaction = false;
        
        std::size_t m_savepoints = 0;

        
        QString m_savepointNamespace;
    };

    

    ManagesTransactions::~ManagesTransactions() = default;

    std::size_t ManagesTransactions::transactionLevel() const
    {
        return m_savepoints;
    }

    bool ManagesTransactions::inTransaction() const
    {
        return m_inTransaction;
    }

    const QString &ManagesTransactions::getSavepointNamespace() const
    {
        return m_savepointNamespace;
    }

} 
} 



#line 131 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/managestransactions.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectors/connectorinterface.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariantHash"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectors/connectorinterface.hpp"





namespace Orm::Connectors
{
    
    using ConnectionName = QString;

    
    class ConnectorInterface
    {
        ConnectorInterface(const ConnectorInterface &) = delete; ConnectorInterface &operator=(const ConnectorInterface &) = delete;

    public:
        
        inline ConnectorInterface() = default;
        
        inline virtual ~ConnectorInterface() = 0;

        
        virtual ConnectionName connect(const QVariantHash &config) const = 0;
    };

    

    ConnectorInterface::~ConnectorInterface() = default;

} 



#line 43 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectors/connectorinterface.hpp"
#line 13 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/queryerror.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/queryerror.hpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/sqlerror.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/QSqlError"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlerror.h"















































class QSqlErrorPrivate;

class __declspec(dllimport) QSqlError
{
public:
    enum ErrorType {
        NoError,
        ConnectionError,
        StatementError,
        TransactionError,
        UnknownError
    };



#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlerror.h"
    QSqlError(const QString &driverText = QString(),
              const QString &databaseText = QString(),
              ErrorType type = NoError,
              const QString &errorCode = QString());
    QSqlError(const QSqlError& other);
    QSqlError(QSqlError &&other) noexcept : d(other.d) { other.d = nullptr; }
    QSqlError& operator=(const QSqlError& other);
    QSqlError &operator=(QSqlError &&other) noexcept { swap(other); return *this; }

    bool operator==(const QSqlError& other) const;
    bool operator!=(const QSqlError& other) const;
    ~QSqlError();

    void swap(QSqlError &other) noexcept { qSwap(d, other.d); }

    QString driverText() const;
    QString databaseText() const;
    ErrorType type() const;


#line 85 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlerror.h"
    QString nativeErrorCode() const;
    QString text() const;
    bool isValid() const;






#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlerror.h"

private:
    
    QString unused1;
    QString unused2;
    struct Unused {
        ErrorType unused3;
        int unused4;
    };
    union {
        QSqlErrorPrivate *d;
        Unused unused5;
    };
};

template<> class QTypeInfo<QSqlError > { public: enum { isSpecialized = true, isComplex = (((((5<<16)|(15<<8)|(11)) >= ((6<<16)|(0<<8)|(0)) ? Q_MOVABLE_TYPE : Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0) && !qIsTrivial<QSqlError>(), isStatic = (((((5<<16)|(15<<8)|(11)) >= ((6<<16)|(0<<8)|(0)) ? Q_MOVABLE_TYPE : Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((((5<<16)|(15<<8)|(11)) >= ((6<<16)|(0<<8)|(0)) ? Q_MOVABLE_TYPE : Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE) || qIsRelocatable<QSqlError>(), isLarge = (sizeof(QSqlError)>sizeof(void*)), isPointer = false, isIntegral = std::is_integral< QSqlError >::value, isDummy = (((((5<<16)|(15<<8)|(11)) >= ((6<<16)|(0<<8)|(0)) ? Q_MOVABLE_TYPE : Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QSqlError) }; static inline const char *name() { return "QSqlError"; } }; inline void swap(QSqlError &value1, QSqlError &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }


__declspec(dllimport) QDebug operator<<(QDebug, const QSqlError &);
#line 115 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlerror.h"



#line 119 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql\\qsqlerror.h"
#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtSql/QSqlError"
#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/sqlerror.hpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/runtimeerror.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/runtimeerror.hpp"



#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/ormerror.hpp"
#pragma once




__pragma(system_header)





namespace Orm::Exceptions
{

    
    class OrmError 
    {
    public:
        
        inline virtual ~OrmError() = 0;
    };

    

    OrmError::~OrmError() = default;

} 



#line 32 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/ormerror.hpp"
#line 13 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/runtimeerror.hpp"




namespace Orm::Exceptions
{

    
    class __declspec(dllexport) RuntimeError : public std::runtime_error, 
                                          public OrmError
    {
    public:
        
        explicit RuntimeError(const char *message);
        
        explicit RuntimeError(const QString &message);
        
        explicit RuntimeError(const std::string &message);

        
        inline const QString &message() const noexcept;

    protected:
        
        QString m_message = what();
    };

    

    const QString &RuntimeError::message() const noexcept
    {
        return m_message;
    }

} 



#line 52 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/runtimeerror.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/sqlerror.hpp"



namespace Orm::Exceptions
{

    
    class __declspec(dllexport) SqlError : public RuntimeError 
    {
    public:
        
        SqlError(const char *message, const QSqlError &error);
        
        SqlError(const QString &message, const QSqlError &error);

        
        SqlError(const char *message, QSqlError &&error);
        
        SqlError(const QString &message, QSqlError &&error);

        
        inline const QSqlError &getSqlError() const noexcept;

    protected:
        

        SqlError(const QString &message, const QSqlError &error, int );

        
        static QString formatMessage(const char *message, const QSqlError &error);

        
        QSqlError m_sqlError;
    };

    

    const QSqlError &SqlError::getSqlError() const noexcept
    {
        return m_sqlError;
    }

} 



#line 58 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/sqlerror.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/queryerror.hpp"

class QSqlQuery;



namespace Orm::Exceptions
{

    
    class __declspec(dllexport) QueryError : public SqlError 
    {
    public:
        
        QueryError(QString connectionName, const char *message, const QSqlQuery &query,
                   const QVector<QVariant> &bindings = {});
        
        QueryError(QString connectionName, const QString &message, const QSqlQuery &query,
                   const QVector<QVariant> &bindings = {});

        
        inline const QString &getConnectionName() const noexcept;
        
        inline const QString &getSql() const noexcept;
        
        inline const QVector<QVariant> &getBindings() const noexcept;

    protected:
        
        static QString formatMessage(const QString &connectionName, const char *message,
                                     const QSqlQuery &query);

        
        QString m_connectionName;
        
        QString m_sql;
        
        QVector<QVariant> m_bindings;
    };

    

    const QString &QueryError::getConnectionName() const noexcept
    {
        return m_connectionName;
    }

    const QString &QueryError::getSql() const noexcept
    {
        return m_sql;
    }

    const QVector<QVariant> &QueryError::getBindings() const noexcept
    {
        return m_bindings;
    }

} 



#line 72 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/queryerror.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/processors/processor.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QStringList"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\qstringlist.h"






























































































































































































































































































































































































































#pragma external_header(pop)
#line 2 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QStringList"
#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/processors/processor.hpp"






namespace Orm
{
namespace Types
{
    class SqlQuery;
}

namespace Query::Processors
{

    
    class __declspec(dllexport) Processor
    {
        Processor(const Processor &) = delete; Processor &operator=(const Processor &) = delete;

        
        using SqlQuery = Orm::Types::SqlQuery;

    public:
        
        inline Processor() = default;
        
        inline virtual ~Processor() = 0;

        
        virtual QStringList processColumnListing(SqlQuery &query) const;
    };

    

    Processor::~Processor() = default;

} 
} 



#line 53 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/query/processors/processor.hpp"
#line 16 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/grammars/schemagrammar.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"


















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"



















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






























#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

#line 34 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"




#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"



#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"












#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 71 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 78 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 87 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
















#line 112 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 113 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"


#line 117 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"









#line 135 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"




#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#line 142 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"




#line 147 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"





#line 153 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"



#line 157 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"


#line 160 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"





#line 167 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"



#line 171 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

#line 173 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"



#line 177 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"







#line 185 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"







#line 194 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"












#line 207 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"






#line 214 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"




#line 219 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"



#line 223 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

#line 225 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

#line 227 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"


namespace meta
{

    using std::integer_sequence;



#line 237 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

    template <typename... Ts>
    struct list;

    template <typename T>
    struct id;

    template <template <typename...> class>
    struct quote;

    template <typename T, template <T...> class F>
    struct quote_i;

    template <template <typename...> class C, typename... Ts>
    struct defer;

    template <typename T, template <T...> class C, T... Is>
    struct defer_i;


    
    
    
    
    template <typename, template <typename...> class>
    inline constexpr bool is_v = false;
    template <typename... Ts, template <typename...> class C>
    inline constexpr bool is_v<C<Ts...>, C> = true;
#line 266 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"


    namespace detail
    {
        template <bool B>
        inline constexpr bool barrier = B;

        template <class T, T> struct require_constant; 
    }

    template <typename...>
    concept is_true = true;

    template <typename T, typename U>
    concept same_as =
        std::is_same_v<T, U>;

    template <template <typename...> class C, typename... Ts>
    concept valid = requires
    {
        typename C<Ts...>;
    };

    template <typename T, template <T...> class C, T... Is>
    concept valid_i = requires
    {
        typename C<Is...>;
    };

    template <typename T>
    concept trait = requires
    {
        typename T::type;
    };

    template <typename T>
    concept invocable = requires
    {
        typename quote<T::template invoke>;
    };

    template <typename T>
    concept list_like = is_v<T, list>;

    
    template <typename T>
    concept integral = requires
    {
        typename T::type;
        typename T::value_type;
        typename T::type::value_type;
    }
    && same_as<typename T::value_type, typename T::type::value_type>

    && std::is_integral_v<typename T::value_type>


#line 324 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

    && requires
    {
        
        T::value;
        requires same_as<decltype(T::value), const typename T::value_type>;
        typename detail::require_constant<decltype(T::value), T::value>;

        
        T::type::value;
        requires same_as<decltype(T::type::value), const typename T::value_type>;
        typename detail::require_constant<decltype(T::type::value), T::type::value>;
        requires T::value == T::type::value;

        
        T{}();
        requires same_as<decltype(T{}()), typename T::value_type>;
        typename detail::require_constant<decltype(T{}()), T{}()>;
        requires T{}() == T::value;

        
    };
    
#line 348 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"

    namespace extension
    {
        template <invocable F, typename L>
        struct apply;
    }
} 





#line 361 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta_fwd.hpp"
#pragma external_header(pop)
#line 21 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"






























































































namespace meta
{
    namespace detail
    {
        
        template <typename T>
        constexpr T *_nullptr_v()
        {
            return nullptr;
        }


        template <typename T>
        inline constexpr T *nullptr_v = nullptr;
#line 130 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 

    
    
    struct nil_
    {
    };

    
    
    template <trait T>
    using _t = typename T::type;


    
    
    
    template <integral T>
    constexpr typename T::type::value_type _v = T::type::value;
#line 150 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    namespace lazy
    {
        
        
        template <typename T>
        using _t = defer<_t, T>;
    } 

    
    
    template <std::size_t N>
    using size_t = std::integral_constant<std::size_t, N>;

    
    
    template <bool B>
    using bool_ = std::integral_constant<bool, B>;

    
    
    template <int I>
    using int_ = std::integral_constant<int, I>;

    
    
    template <char Ch>
    using char_ = std::integral_constant<char, Ch>;

    
    
    
    
    template <integral T>
    using inc = std::integral_constant<decltype(T::type::value + 1), T::type::value + 1>;

    
    
    template <integral T>
    using dec = std::integral_constant<decltype(T::type::value - 1), T::type::value - 1>;

    
    
    
    template <integral T, integral U>
    using plus = std::integral_constant<decltype(T::type::value + U::type::value),
                                        T::type::value + U::type::value>;

    
    
    
    template <integral T, integral U>
    using minus = std::integral_constant<decltype(T::type::value - U::type::value),
                                            T::type::value - U::type::value>;

    
    
    
    template <integral T, integral U>
    using multiplies = std::integral_constant<decltype(T::type::value * U::type::value),
                                                T::type::value * U::type::value>;

    
    
    
    template <integral T, integral U>
    using divides = std::integral_constant<decltype(T::type::value / U::type::value),
                                            T::type::value / U::type::value>;

    
    
    
    template <integral T>
    using negate = std::integral_constant<decltype(-T::type::value), -T::type::value>;

    
    
    
    template <integral T, integral U>
    using modulus = std::integral_constant<decltype(T::type::value % U::type::value),
                                            T::type::value % U::type::value>;

    
    
    
    template <integral T, integral U>
    using equal_to = bool_<T::type::value == U::type::value>;

    
    
    
    template <integral T, integral U>
    using not_equal_to = bool_<T::type::value != U::type::value>;

    
    
    
    template <integral T, integral U>
    using greater = bool_<(T::type::value > U::type::value)>;

    
    
    
    template <integral T, integral U>
    using less = bool_<(T::type::value < U::type::value)>;

    
    
    
    template <integral T, integral U>
    using greater_equal = bool_<(T::type::value >= U::type::value)>;

    
    
    
    template <integral T, integral U>
    using less_equal = bool_<(T::type::value <= U::type::value)>;

    
    
    
    template <integral T, integral U>
    using bit_and = std::integral_constant<decltype(T::type::value & U::type::value),
                                            T::type::value & U::type::value>;

    
    
    
    template <integral T, integral U>
    using bit_or = std::integral_constant<decltype(T::type::value | U::type::value),
                                            T::type::value | U::type::value>;

    
    
    
    template <integral T, integral U>
    using bit_xor = std::integral_constant<decltype(T::type::value ^ U::type::value),
                                            T::type::value ^ U::type::value>;

    
    
    
    template <integral T>
    using bit_not = std::integral_constant<decltype(~T::type::value), ~T::type::value>;

    namespace lazy
    {
        
        
        template <typename T>
        using inc = defer<inc, T>;

        
        
        template <typename T>
        using dec = defer<dec, T>;

        
        
        template <typename T, typename U>
        using plus = defer<plus, T, U>;

        
        
        template <typename T, typename U>
        using minus = defer<minus, T, U>;

        
        
        template <typename T, typename U>
        using multiplies = defer<multiplies, T, U>;

        
        
        template <typename T, typename U>
        using divides = defer<divides, T, U>;

        
        
        template <typename T>
        using negate = defer<negate, T>;

        
        
        template <typename T, typename U>
        using modulus = defer<modulus, T, U>;

        
        
        template <typename T, typename U>
        using equal_to = defer<equal_to, T, U>;

        
        
        template <typename T, typename U>
        using not_equal_to = defer<not_equal_to, T, U>;

        
        
        template <typename T, typename U>
        using greater = defer<greater, T, U>;

        
        
        template <typename T, typename U>
        using less = defer<less, T, U>;

        
        
        template <typename T, typename U>
        using greater_equal = defer<greater_equal, T, U>;

        
        
        template <typename T, typename U>
        using less_equal = defer<less_equal, T, U>;

        
        
        template <typename T, typename U>
        using bit_and = defer<bit_and, T, U>;

        
        
        template <typename T, typename U>
        using bit_or = defer<bit_or, T, U>;

        
        
        template <typename T, typename U>
        using bit_xor = defer<bit_xor, T, U>;

        
        
        template <typename T>
        using bit_not = defer<bit_not, T>;
    } 

    
    namespace detail
    {
        enum class indices_strategy_
        {
            done,
            repeat,
            recurse
        };

        constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
        {
            return cur >= end ? indices_strategy_::done
                              : cur * 2 <= end ? indices_strategy_::repeat
                                               : indices_strategy_::recurse;
        }

        template <typename T>
        constexpr std::size_t range_distance_(T begin, T end)
        {
            return begin <= end ? static_cast<std::size_t>(end - begin)
                                : throw "The start of the integer_sequence must not be "
                                        "greater than the end";
        }

        template <std::size_t End, typename State, indices_strategy_ Status_>
        struct make_indices_
        {
            using type = State;
        };

        template <typename T, T, typename>
        struct coerce_indices_
        {
        };
    } 
    

    
    










#line 440 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    
    
    template <std::size_t... Is>
    using index_sequence = integer_sequence<std::size_t, Is...>;


    
    
    
    
    namespace detail
    {
        template <typename T, T N>
        __make_integer_seq<integer_sequence, T, N> make_integer_sequence_();
    }
    

    template <typename T, T N>
    using make_integer_sequence = decltype(detail::make_integer_sequence_<T, N>());

    template <std::size_t N>
    using make_index_sequence = make_integer_sequence<std::size_t, N>;
















#line 483 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    
    
    
    template <typename T, T From, T To>
    using integer_range =
        _t<detail::coerce_indices_<T, From,
                                    make_index_sequence<detail::range_distance_(From, To)>>>;

    
    namespace detail
    {
        template <typename, typename>
        struct concat_indices_
        {
        };

        template <std::size_t... Is, std::size_t... Js>
        struct concat_indices_<index_sequence<Is...>, index_sequence<Js...>>
        {
            using type = index_sequence<Is..., (Js + sizeof...(Is))...>;
        };

        template <>
        struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
        {
            using type = index_sequence<>;
        };

        template <std::size_t End, std::size_t... Values>
        struct make_indices_<End, index_sequence<Values...>, indices_strategy_::repeat>
          : make_indices_<End, index_sequence<Values..., (Values + sizeof...(Values))...>,
                          detail::strategy_(sizeof...(Values) * 2, End)>
        {
        };

        template <std::size_t End, std::size_t... Values>
        struct make_indices_<End, index_sequence<Values...>, indices_strategy_::recurse>
          : concat_indices_<index_sequence<Values...>,
                            make_index_sequence<End - sizeof...(Values)>>
        {
        };

        template <typename T, T Offset, std::size_t... Values>
        struct coerce_indices_<T, Offset, index_sequence<Values...>>
        {
            using type =
                integer_sequence<T, static_cast<T>(static_cast<T>(Values) + Offset)...>;
        };
    } 
    

    
    
    template <invocable Fn, typename... Args>
    using invoke = typename Fn::template invoke<Args...>;

    
    namespace lazy
    {
        
        
        template <typename Fn, typename... Args>
        using invoke = defer<invoke, Fn, Args...>;
    } 

    
    
    
    
    template <typename T>
    struct id
    {







#line 567 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        template <typename...>
        using invoke = T;
#line 570 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

        using type = T;
    };

    
    
    template <typename T>
    using id_t = _t<id<T>>;

    namespace lazy
    {
        
        
        
        template <typename T>
        using id = defer<id, T>;
    } 

    
    





#line 596 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    template <typename...>
    using void_ = void;
#line 599 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"



    
    
    template <typename T>
    inline constexpr bool is_trait_v = trait<T>;

    
    
    template <typename T>
    inline constexpr bool is_callable_v = invocable<T>;



























#line 639 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    template <typename T>
    using is_trait = bool_<is_trait_v<T>>;

    
    
    
    template <typename T>
    using is_callable = bool_<is_callable_v<T>>;







































#line 691 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    namespace detail
    {

        template <template <typename...> class, typename...>
        struct defer_
        {
        };

        template <template <typename...> class C, typename... Ts>
        requires valid<C, Ts...> struct defer_<C, Ts...>
        {
            using type = C<Ts...>;
        };

        template <typename T, template <T...> class, T...>
        struct defer_i_
        {
        };

        template <typename T, template <T...> class C, T... Is>
        requires valid_i<T, C, Is...> struct defer_i_<T, C, Is...>
        {
            using type = C<Is...>;
        };













































#line 763 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

        template <typename T>
        using _t_t = _t<_t<T>>;
    } 
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    template <template <typename...> class C, typename... Ts>
    struct defer : detail::defer_<C, Ts...>
    {
    };

    
    
    
    
    
    
    template <typename T, template <T...> class C, T... Is>
    struct defer_i : detail::defer_i_<T, C, Is...>
    {
    };

    
    
    
    
    
    
    template <template <typename...> class C, typename... Ts>
    using defer_trait = defer<detail::_t_t, detail::defer_<C, Ts...>>;

    
    
    
    
    
    
    template <typename T, template <T...> class C, T... Is>
    using defer_trait_i = defer<detail::_t_t, detail::defer_i_<T, C, Is...>>;

    
    
    
    
    template <typename T>
    using sizeof_ = meta::size_t<sizeof(T)>;

    
    
    
    
    template <typename T>
    using alignof_ = meta::size_t<alignof(T)>;

    namespace lazy
    {
        
        
        template <typename T>
        using sizeof_ = defer<sizeof_, T>;

        
        
        template <typename T>
        using alignof_ = defer<alignof_, T>;
    } 


    
    
    
    
    template <typename T, template <typename...> class C>
    using is = bool_<is_v<T, C>>;






















#line 876 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    template <invocable... Fns>
    struct compose_
    {
    };

    template <invocable Fn0>
    struct compose_<Fn0>
    {
        template <typename... Ts>
        using invoke = invoke<Fn0, Ts...>;
    };

    template <invocable Fn0, invocable... Fns>
    struct compose_<Fn0, Fns...>
    {
        template <typename... Ts>
        using invoke = invoke<Fn0, invoke<compose_<Fns...>, Ts...>>;
    };

    template <typename... Fns>
    using compose = compose_<Fns...>;

    namespace lazy
    {
        
        
        template <typename... Fns>
        using compose = defer<compose, Fns...>;
    } 

    
    
    template <template <typename...> class C>
    struct quote
    {
        
        
        template <typename... Ts>
        using invoke = _t<defer<C, Ts...>>;
    };

    
    
    
    template <typename T, template <T...> class C>
    struct quote_i
    {
        
        
        template <integral... Ts>
        using invoke = _t<defer_i<T, C, Ts::type::value...>>;
    };















#line 948 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    
    
    
    
    
    
    template <template <typename...> class C>
    using quote_trait = compose<quote<_t>, quote<C>>;

    
    
    template <typename T, template <T...> class C>
    using quote_trait_i = compose<quote<_t>, quote_i<T, C>>;
    
#line 963 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    template <invocable Fn, typename... Ts>
    struct bind_front
    {
        template <typename... Us>
        using invoke = invoke<Fn, Ts..., Us...>;
    };

    
    
    
    template <invocable Fn, typename... Us>
    struct bind_back
    {
        template <typename... Ts>
        using invoke = invoke<Fn, Ts..., Us...>;
    };

    namespace lazy
    {
        
        
        template <typename Fn, typename... Ts>
        using bind_front = defer<bind_front, Fn, Ts...>;

        
        
        template <typename Fn, typename... Ts>
        using bind_back = defer<bind_back, Fn, Ts...>;
    } 

    
    namespace extension
    {
        
        
        
        template <invocable Fn, typename L>
        struct apply
        {
        };

        template <invocable Fn, typename Ret, typename... Args>
        struct apply<Fn, Ret(Args...)> : lazy::invoke<Fn, Ret, Args...>
        {
        };

        template <invocable Fn, template <typename...> class T,
                    typename... Ts>
        struct apply<Fn, T<Ts...>> : lazy::invoke<Fn, Ts...>
        {
        };

        template <invocable Fn, typename T, T... Is>
        struct apply<Fn, integer_sequence<T, Is...>>
          : lazy::invoke<Fn, std::integral_constant<T, Is>...>
        {
        };
    } 

    
    
    
    template <invocable Fn, typename L>
    using apply = _t<extension::apply<Fn, L>>;

    namespace lazy
    {
        template <typename Fn, typename L>
        using apply = defer<apply, Fn, L>;
    }

    
    
    
    template <invocable Fn,
                invocable Q = quote<list>>
    using curry = compose<Fn, Q>;

    
    
    
    template <invocable Fn>
    using uncurry = bind_front<quote<apply>, Fn>;

    namespace lazy
    {
        
        
        template <typename Fn, typename Q = quote<list>>
        using curry = defer<curry, Fn, Q>;

        
        
        template <typename Fn>
        using uncurry = defer<uncurry, Fn>;
    } 

    
    
    template <invocable Fn>
    struct flip
    {
    private:
        template <typename... Ts>
        struct impl
        {
        };
        template <typename A, typename B, typename... Ts>
        struct impl<A, B, Ts...> : lazy::invoke<Fn, B, A, Ts...>
        {
        };

    public:
        template <typename... Ts>
        using invoke = _t<impl<Ts...>>;
    };

    namespace lazy
    {
        
        
        template <typename Fn>
        using flip = defer<flip, Fn>;
    } 

    
    namespace detail
    {
        template <typename...>
        struct on_
        {
        };
        template <typename Fn, typename... Gs>
        struct on_<Fn, Gs...>
        {
            template <typename... Ts>
            using invoke = invoke<Fn, invoke<compose<Gs...>, Ts>...>;
        };
    } 
    

    
    
    
    template <invocable... Fns>
    using on_ = detail::on_<Fns...>;

    template <typename... Fns>
    using on = on_<Fns...>;

    namespace lazy
    {
        
        
        template <typename Fn, typename G>
        using on = defer<on, Fn, G>;
    } 

    
    
    
    namespace detail
    {
        template <bool>
        struct _cond
        {
            template <typename Then, typename Else>
            using invoke = Then;
        };
        template <>
        struct _cond<false>
        {
            template <typename Then, typename Else>
            using invoke = Else;
        };
    } 
    

    
    
    template <bool If, typename Then, typename Else = void>
    using conditional_t = typename detail::_cond<If>::template invoke<Then, Else>;

    
    
    
    namespace detail
    {

        template <typename...>
        struct _if_
        {
        };

        template <typename If>
            requires integral<If>
        struct _if_<If> : std::enable_if<_v<If>>
        {
        };

        template <typename If, typename Then>
            requires integral<If>
        struct _if_<If, Then> : std::enable_if<_v<If>, Then>
        {
        };

        template <typename If, typename Then, typename Else>
            requires integral<If>
        struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
        {
        };





















































#line 1232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
        

    
    

    template <typename... Args>
    using if_ = _t<detail::_if_<Args...>>;

    
    
    template <bool If, typename... Args>
    using if_c = _t<detail::_if_<bool_<If>, Args...>>;






#line 1252 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    namespace lazy
    {
        
        
        template <typename... Args>
        using if_ = defer<if_, Args...>;

        
        
        template <bool If, typename... Args>
        using if_c = if_<bool_<If>, Args...>;
    } 

    
    namespace detail
    {

        template <typename...>
        struct _and_
        {
        };

        template <>
        struct _and_<> : std::true_type
        {
        };

        template <typename B, typename... Bs>
            requires integral<B> && (bool(B::type::value))
        struct _and_<B, Bs...> : _and_<Bs...>
        {
        };

        template <typename B, typename... Bs>
            requires integral<B> && (!bool(B::type::value))
        struct _and_<B, Bs...> : std::false_type
        {
        };

        template <typename...>
        struct _or_
        {
        };

        template <>
        struct _or_<> : std::false_type
        {
        };

        template <typename B, typename... Bs>
            requires integral<B> && (bool(B::type::value))
        struct _or_<B, Bs...> : std::true_type
        {
        };

        template <typename B, typename... Bs>
            requires integral<B> && (!bool(B::type::value))
        struct _or_<B, Bs...> : _or_<Bs...>
        {
        };
































#line 1346 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
    

    
    
    template <bool B>
    using not_c = bool_<!B>;

    
    
    template <integral B>
    using not_ = not_c<B::type::value>;


    template <bool... Bs>
    inline constexpr bool and_v = (true && ... && Bs);

    
    
    template <bool... Bs>


#line 1369 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    using and_c = bool_<(true && ... && Bs)>;
#line 1371 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"




















#line 1392 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    template <integral... Bs>
    using strict_and_ = and_c<Bs::type::value...>;

    template <typename... Bs>
    using strict_and = strict_and_<Bs...>;

    
    
    
    template <typename... Bs>

    using and_ = _t<detail::_and_<Bs...>>;




#line 1413 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    

    template <bool... Bs>
    inline constexpr bool or_v = (false || ... || Bs);

    template <bool... Bs>


#line 1424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    using or_c = bool_<(false || ... || Bs)>;
#line 1426 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"













#line 1440 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    template <integral... Bs>
    using strict_or_ = or_c<Bs::type::value...>;

    template <typename... Bs>
    using strict_or = strict_or_<Bs...>;

    
    
    
    template <typename... Bs>

    using or_ = _t<detail::_or_<Bs...>>;




#line 1461 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    namespace lazy
    {
        
        
        template <typename... Bs>
        using and_ = defer<and_, Bs...>;

        
        
        template <typename... Bs>
        using or_ = defer<or_, Bs...>;

        
        
        template <typename B>
        using not_ = defer<not_, B>;

        
        
        template <typename... Bs>
        using strict_and = defer<strict_and, Bs...>;

        
        
        template <typename... Bs>
        using strict_or = defer<strict_or, Bs...>;
    } 

    
    
    
    namespace detail
    {
        template <typename, typename, typename>
        struct fold_
        {
        };

        template <typename Fn, typename T0, typename T1, typename T2, typename T3, typename T4,
                    typename T5, typename T6, typename T7, typename T8, typename T9>
        struct compose10_
        {
            template <typename X, typename Y>
            using F = invoke<Fn, X, Y>;

            template <typename S>
            using invoke =
                F<F<F<F<F<F<F<F<F<F<_t<S>, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
        };


        template <typename Fn>
        struct compose_
        {
            template <typename X, typename Y>
            using F = invoke<Fn, X, Y>;

            template <typename T0, typename T1, typename T2, typename T3, typename T4,
                        typename T5, typename T6, typename T7, typename T8, typename T9,
                        typename State>
            using invoke =
                F<F<F<F<F<F<F<F<F<F<State, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
        };

        template <typename State, typename Fn>
        struct fold_<list<>, State, Fn>
        {
            using type = State;
        };

        template <typename Head, typename... Tail, typename State, typename Fn>
        requires valid<invoke, Fn, State, Head>
        struct fold_<list<Head, Tail...>, State, Fn>
          : fold_<list<Tail...>, invoke<Fn, State, Head>, Fn>
        {
        };

        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
                    typename T6, typename T7, typename T8, typename T9, typename... Tail,
                    typename State, typename Fn>
        requires valid<invoke, compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>
        struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
          : fold_<list<Tail...>,
                  invoke<compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>, Fn>
        {
        };



























#line 1576 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
    

    
    
    
    
    
    
    template <list_like L, typename State, invocable Fn>

    using fold = _t<detail::fold_<L, State, Fn>>;


#line 1591 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    
    template <list_like L, typename State, invocable Fn>
    using accumulate = fold<L, State, Fn>;

    namespace lazy
    {
        
        
        template <typename L, typename State, typename Fn>
        using fold = defer<fold, L, State, Fn>;

        
        
        template <typename L, typename State, typename Fn>
        using accumulate = defer<accumulate, L, State, Fn>;
    } 

    
    
    
    namespace detail
    {
        template <typename, typename, typename>
        struct reverse_fold_
        {
        };

        template <typename State, typename Fn>
        struct reverse_fold_<list<>, State, Fn>
        {
            using type = State;
        };


        template <typename Head, typename... L, typename State, typename Fn>
        requires trait<reverse_fold_<list<L...>, State, Fn>> struct reverse_fold_<
            list<Head, L...>, State, Fn>
          : lazy::invoke<Fn, _t<reverse_fold_<list<L...>, State, Fn>>, Head>
        {
        };






#line 1642 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
                    typename T6, typename T7, typename T8, typename T9, typename... Tail,
                    typename State, typename Fn>
        struct reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
          : lazy::invoke<compose10_<Fn, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>,
                            reverse_fold_<list<Tail...>, State, Fn>>
        {
        };
    } 
    

    
    
    
    
    
    
    template <list_like L, typename State, invocable Fn>
    using reverse_fold = _t<detail::reverse_fold_<L, State, Fn>>;

    namespace lazy
    {
        
        
        template <typename L, typename State, typename Fn>
        using reverse_fold = defer<reverse_fold, L, State, Fn>;
    } 

    
    
    
    
    
    using npos = meta::size_t<std::size_t(-1)>;

    
    
    
    
    template <typename... Ts>
    struct list
    {
        using type = list;
        
        static constexpr std::size_t size() noexcept { return sizeof...(Ts); }
    };

    
    
    
    
    
    template <list_like L>
    using size = meta::size_t<L::size()>;

    namespace lazy
    {
        
        
        template <typename L>
        using size = defer<size, L>;
    } 

    
    
    
    namespace detail
    {
        template <typename... Lists>
        struct concat_
        {
        };

        template <>
        struct concat_<>
        {
            using type = list<>;
        };

        template <typename... L1>
        struct concat_<list<L1...>>
        {
            using type = list<L1...>;
        };

        template <typename... L1, typename... L2>
        struct concat_<list<L1...>, list<L2...>>
        {
            using type = list<L1..., L2...>;
        };

        template <typename... L1, typename... L2, typename... L3>
        struct concat_<list<L1...>, list<L2...>, list<L3...>>
        {
            using type = list<L1..., L2..., L3...>;
        };

        template <typename... L1, typename... L2, typename... L3, typename... Rest>
        struct concat_<list<L1...>, list<L2...>, list<L3...>, Rest...>
          : concat_<list<L1..., L2..., L3...>, Rest...>
        {
        };

        template <typename... L1, typename... L2, typename... L3, typename... L4,
                    typename... L5, typename... L6, typename... L7, typename... L8,
                    typename... L9, typename... L10, typename... Rest>
        struct concat_<list<L1...>, list<L2...>, list<L3...>, list<L4...>, list<L5...>,
                        list<L6...>, list<L7...>, list<L8...>, list<L9...>, list<L10...>,
                        Rest...>
          : concat_<list<L1..., L2..., L3..., L4..., L5..., L6..., L7..., L8..., L9..., L10...>,
                    Rest...>
        {
        };
    } 
    

    
    
    
    
    
    template <list_like... Ls>
    using concat_ = _t<detail::concat_<Ls...>>;

    template <typename... Lists>
    using concat = concat_<Lists...>;

    namespace lazy
    {
        
        
        template <typename... Lists>
        using concat = defer<concat, Lists...>;
    } 

    
    
    
    
    
    
    
    template <list_like ListOfLists>
    using join = apply<quote<concat>, ListOfLists>;

    namespace lazy
    {
        
        
        template <typename ListOfLists>
        using join = defer<join, ListOfLists>;
    } 

    
    
    
    namespace detail
    {

        template <typename... Args>
        struct transform_
        {
        };

        template <typename... Ts, typename Fn>
            requires invocable<Fn> && and_v<valid<invoke, Fn, Ts>...>
        struct transform_<list<Ts...>, Fn>
        {
            using type = list<invoke<Fn, Ts>...>;
        };

        template <typename... Ts, typename... Us, typename Fn>
            requires invocable<Fn> && and_v<valid<invoke, Fn, Ts, Us>...>
        struct transform_<list<Ts...>, list<Us...>, Fn>
        {
            using type = list<invoke<Fn, Ts, Us>...>;
        };


















#line 1839 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
        

    
    
    
    
    
    
    
    

    template <typename... Args>
    using transform = _t<detail::transform_<Args...>>;



#line 1857 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    namespace lazy
    {
        
        
        template <typename... Args>
        using transform = defer<transform, Args...>;
    } 

    
    
    
    namespace detail
    {
        template <typename T, std::size_t>
        using first_ = T;

        template <typename T, typename Ints>
        struct repeat_n_c_
        {
        };

        template <typename T, std::size_t... Is>
        struct repeat_n_c_<T, index_sequence<Is...>>
        {
            using type = list<first_<T, Is>...>;
        };
    } 
    

    
    
    
    
    template <std::size_t N, typename T = void>
    using repeat_n_c = _t<detail::repeat_n_c_<T, make_index_sequence<N>>>;

    
    
    
    
    template <integral N, typename T = void>
    using repeat_n = repeat_n_c<N::type::value, T>;

    namespace lazy
    {
        
        
        template <typename N, typename T = void>
        using repeat_n = defer<repeat_n, N, T>;

        
        
        template <std::size_t N, typename T = void>
        using repeat_n_c = defer<repeat_n, meta::size_t<N>, T>;
    } 

    
    
    
    namespace detail
    {











#line 1931 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        template <typename VoidPtrs>
        struct at_impl_;

        template <typename... VoidPtrs>
        struct at_impl_<list<VoidPtrs...>>
        {
            static nil_ eval(...);

            template <typename T, typename... Us>
            static T eval(VoidPtrs..., T *, Us *...);
        };

        template <typename L, std::size_t N>
        struct at_
        {
        };

        template <typename... Ts, std::size_t N>
        struct at_<list<Ts...>, N>
          : decltype(at_impl_<repeat_n_c<N, void *>>::eval(static_cast<id<Ts> *>(nullptr)...))
        {
        };
#line 1954 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
    

    
    
    
    
    template <list_like L, std::size_t N>
    using at_c = _t<detail::at_<L, N>>;

    
    
    
    
    template <list_like L, integral N>
    using at = at_c<L, N::type::value>;

    namespace lazy
    {
        
        
        template <typename L, typename N>
        using at = defer<at, L, N>;
    } 

    
    
    
    namespace detail
    {
        
        
        template <typename VoidPtrs>
        struct drop_impl_
        {
            static nil_ eval(...);
        };

        template <typename... VoidPtrs>
        struct drop_impl_<list<VoidPtrs...>>
        {
            static nil_ eval(...);

            template <typename... Ts>
            static id<list<Ts...>> eval(VoidPtrs..., id<Ts> *...);
        };

        template <>
        struct drop_impl_<list<>>
        {
            template <typename... Ts>
            static id<list<Ts...>> eval(id<Ts> *...);
        };

        template <typename L, std::size_t N>
        struct drop_
        {
        };

        template <typename... Ts, std::size_t N>
        struct drop_<list<Ts...>, N>

          : decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::nullptr_v<id<Ts>>...))


#line 2020 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        {
        };
    } 
    

    
    
    
    
    template <list_like L, std::size_t N>
    using drop_c = _t<detail::drop_<L, N>>;

    
    
    
    
    template <list_like L, integral N>
    using drop = drop_c<L, N::type::value>;

    namespace lazy
    {
        
        
        template <typename L, typename N>
        using drop = defer<drop, L, N>;
    } 

    
    
    
    namespace detail
    {
        template <typename L>
        struct front_
        {
        };

        template <typename Head, typename... Tail>
        struct front_<list<Head, Tail...>>
        {
            using type = Head;
        };
    } 
    

    
    
    
    
    template <list_like L>
    using front = _t<detail::front_<L>>;

    namespace lazy
    {
        
        
        template <typename L>
        using front = defer<front, L>;
    } 

    
    
    
    namespace detail
    {
        template <typename L>
        struct back_
        {
        };

        template <typename Head, typename... Tail>
        struct back_<list<Head, Tail...>>
        {
            using type = at_c<list<Head, Tail...>, sizeof...(Tail)>;
        };
    } 
    

    
    
    
    
    template <list_like L>
    using back = _t<detail::back_<L>>;

    namespace lazy
    {
        
        
        template <typename L>
        using back = defer<back, L>;
    } 

    
    
    
    
    
    
    template <list_like L, typename... Ts>
    using push_front = apply<bind_front<quote<list>, Ts...>, L>;

    namespace lazy
    {
        
        
        template <typename... Ts>
        using push_front = defer<push_front, Ts...>;
    } 

    
    
    
    namespace detail
    {
        template <typename L>
        struct pop_front_
        {
        };

        template <typename Head, typename... L>
        struct pop_front_<list<Head, L...>>
        {
            using type = list<L...>;
        };
    } 
    

    
    
    
    
    
    template <list_like L>
    using pop_front = _t<detail::pop_front_<L>>;

    namespace lazy
    {
        
        
        template <typename L>
        using pop_front = defer<pop_front, L>;
    } 

    
    
    
    
    
    
    
    
    template <list_like L, typename... Ts>
    using push_back = apply<bind_back<quote<list>, Ts...>, L>;

    namespace lazy
    {
        
        
        template <typename... Ts>
        using push_back = defer<push_back, Ts...>;
    } 

    
    namespace detail
    {
        template <typename T, typename U>
        using min_ = if_<less<U, T>, U, T>;

        template <typename T, typename U>
        using max_ = if_<less<U, T>, T, U>;
    } 
    

    
    
    template <integral... Ts>
    using min_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::min_>>;

    template <typename... Ts>
    using min = min_<Ts...>;

    
    
    template <integral... Ts>
    using max_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::max_>>;

    template <typename... Ts>
    using max = max_<Ts...>;

    namespace lazy
    {
        
        
        template <typename... Ts>
        using min = defer<min, Ts...>;

        
        
        template <typename... Ts>
        using max = defer<max, Ts...>;
    } 

    
    
    
    
    
    
    
    template <list_like L>
    using empty = bool_<0 == size<L>::type::value>;

    namespace lazy
    {
        
        
        template <typename L>
        using empty = defer<empty, L>;
    } 

    
    
    
    
    template <typename F, typename S>
    using pair = list<F, S>;

    
    
    template <typename Pair>
    using first = front<Pair>;

    
    
    template <typename Pair>
    using second = front<pop_front<Pair>>;

    namespace lazy
    {
        
        
        template <typename Pair>
        using first = defer<first, Pair>;

        
        
        template <typename Pair>
        using second = defer<second, Pair>;
    } 

    
    
    
    namespace detail
    {
        
        constexpr std::size_t find_index_i_(bool const *const first, bool const *const last,
                                            std::size_t N = 0)
        {
            return first == last ? npos::value
                                 : *first ? N : find_index_i_(first + 1, last, N + 1);
        }

        template <typename L, typename T>
        struct find_index_
        {
        };

        template <typename V>
        struct find_index_<list<>, V>
        {
            using type = npos;
        };

        template <typename... T, typename V>
        struct find_index_<list<T...>, V>
        {



            static constexpr bool s_v[] = {std::is_same_v<T, V>...};
#line 2303 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            using type = size_t<find_index_i_(s_v, s_v + sizeof...(T))>;
        };
    } 
    

    
    
    
    
    
    
    template <list_like L, typename T>
    using find_index = _t<detail::find_index_<L, T>>;

    namespace lazy
    {
        
        
        template <typename L, typename T>
        using find_index = defer<find_index, L, T>;
    } 

    
    
    
    namespace detail
    {
        
        constexpr std::size_t reverse_find_index_i_(bool const *const first,
                                                    bool const *const last, std::size_t N)
        {
            return first == last
                ? npos::value
                : *(last - 1) ? N - 1 : reverse_find_index_i_(first, last - 1, N - 1);
        }

        template <typename L, typename T>
        struct reverse_find_index_
        {
        };

        template <typename V>
        struct reverse_find_index_<list<>, V>
        {
            using type = npos;
        };

        template <typename... T, typename V>
        struct reverse_find_index_<list<T...>, V>
        {



            static constexpr bool s_v[] = {std::is_same_v<T, V>...};
#line 2358 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            using type = size_t<reverse_find_index_i_(s_v, s_v + sizeof...(T), sizeof...(T))>;
        };
    } 
    

    
    
    
    
    
    
    template <list_like L, typename T>
    using reverse_find_index = _t<detail::reverse_find_index_<L, T>>;

    namespace lazy
    {
        
        
        template <typename L, typename T>
        using reverse_find_index = defer<reverse_find_index, L, T>;
    } 

    
    
    
    
    
    
    
    template <list_like L, typename T>
    using find = drop<L, min<find_index<L, T>, size<L>>>;

    namespace lazy
    {
        
        
        template <typename L, typename T>
        using find = defer<find, L, T>;
    } 

    
    
    
    namespace detail
    {
        template <typename L, typename T, typename State = list<>>
        struct reverse_find_
        {
        };

        template <typename T, typename State>
        struct reverse_find_<list<>, T, State>
        {
            using type = State;
        };

        template <typename Head, typename... L, typename T, typename State>
        struct reverse_find_<list<Head, L...>, T, State> : reverse_find_<list<L...>, T, State>
        {
        };

        template <typename... L, typename T, typename State>
        struct reverse_find_<list<T, L...>, T, State>
          : reverse_find_<list<L...>, T, list<T, L...>>
        {
        };
    } 
    

    
    
    
    
    
    template <list_like L, typename T>
    using reverse_find = drop<L, min<reverse_find_index<L, T>, size<L>>>;

    namespace lazy
    {
        
        
        template <typename L, typename T>
        using reverse_find = defer<reverse_find, L, T>;
    } 

    
    
    
    namespace detail
    {

        template <typename L, typename Fn>
        struct find_if_
        {
        };

        template <typename Fn>
        struct find_if_<list<>, Fn>
        {
            using type = list<>;
        };

        template <typename Head, typename... L, typename Fn>
        requires integral<invoke<Fn, Head>>
        struct find_if_<list<Head, L...>, Fn>
          : if_<invoke<Fn, Head>, id<list<Head, L...>>, find_if_<list<L...>, Fn>>
        {
        };





























#line 2496 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
    

    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using find_if = _t<detail::find_if_<L, Fn>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using find_if = defer<find_if, L, Fn>;
    } 

    
    
    
    namespace detail
    {

        template <typename L, typename Fn, typename State = list<>>
        struct reverse_find_if_
        {
        };

        template <typename Fn, typename State>
        struct reverse_find_if_<list<>, Fn, State>
        {
            using type = State;
        };

        template <typename Head, typename... L, typename Fn, typename State>
        requires integral<invoke<Fn, Head>>
        struct reverse_find_if_<list<Head, L...>, Fn, State>
          : reverse_find_if_<list<L...>, Fn, if_<invoke<Fn, Head>, list<Head, L...>, State>>
        {
        };



































#line 2575 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
    

    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using reverse_find_if = _t<detail::reverse_find_if_<L, Fn>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using reverse_find_if = defer<reverse_find_if, L, Fn>;
    } 

    
    
    
    namespace detail
    {
        template <typename L, typename T, typename U>
        struct replace_
        {
        };

        template <typename... L, typename T, typename U>
        struct replace_<list<L...>, T, U>
        {
            using type = list<if_c<std::is_same_v<T, L>, U, L>...>;
        };
    } 
    

    
    
    
    
    
    template <list_like L, typename T, typename U>
    using replace = _t<detail::replace_<L, T, U>>;

    namespace lazy
    {
        
        
        template <typename L, typename T, typename U>
        using replace = defer<replace, T, U>;
    } 

    
    
    
    namespace detail
    {

        template <typename L, typename C, typename U>
        struct replace_if_
        {
        };

        template <typename... L, typename C, typename U>
        requires and_v<integral<invoke<C, L>>...>
        struct replace_if_<list<L...>, C, U>
        {
            using type = list<if_<invoke<C, L>, U, L>...>;
        };












#line 2659 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 
    

    
    
    
    
    
    
    template <list_like L, typename C, typename U>
    using replace_if = _t<detail::replace_if_<L, C, U>>;

    namespace lazy
    {
        
        
        template <typename L, typename C, typename U>
        using replace_if = defer<replace_if, C, U>;
    } 

    
    
    namespace detail
    {
        template <typename, typename>
        struct count_
        {
        };


        template <typename... Ts, typename T>
        struct count_<list<Ts...>, T>
        {
            using type = meta::size_t<((std::size_t)std::is_same_v<T, Ts> + ...)>;
        };























#line 2718 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 

    
    
    
    
    template <list_like L, typename T>
    using count = _t<detail::count_<L, T>>;

    namespace lazy
    {
        
        
        template <typename L, typename T>
        using count = defer<count, L, T>;
    } 

    
    
    namespace detail
    {

        template <typename, typename>
        struct count_if_
        {
        };

        template <typename... Ts, typename Fn>
        requires (integral<invoke<Fn, Ts>> && ...)
        struct count_if_<list<Ts...>, Fn>
        {
            using type = meta::size_t<((std::size_t)(bool)_v<invoke<Fn, Ts>> + ...)>;
        };



























#line 2779 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
    } 

    
    
    
    
    
    template <list_like L, invocable Fn>
    using count_if = _t<detail::count_if_<L, Fn>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using count_if = defer<count_if, L, Fn>;
    } 

    
    
    
    namespace detail
    {
        template <typename Pred>
        struct filter_
        {
            template <typename A>
            using invoke = if_c<invoke<Pred, A>::type::value, list<A>, list<>>;
        };
    } 
    

    
    
    
    
    
    
    template <typename L, typename Pred>
    using filter = join<transform<L, detail::filter_<Pred>>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using filter = defer<filter, L, Fn>;
    } 

    
    
    
    namespace detail
    {
        template <typename T>
        struct static_const
        {
            static constexpr T value{};
        };

        
        template <typename T>
        constexpr T static_const<T>::value;
    } 

    

    
    
    
    namespace detail
    {
        struct for_each_fn
        {
            template <class Fn, class... Args>
            constexpr auto operator()(list<Args...>, Fn f) const -> Fn
            {
                return (void)std::initializer_list<int>{((void)f(Args{}), 0)...}, f;
            }
        };
    } 
    


    
    
    
    inline constexpr detail::for_each_fn for_each{};














#line 2882 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    
    
    
    
    template <list_like ListOfLists>
    using transpose = fold<ListOfLists, repeat_n<size<front<ListOfLists>>, list<>>,
                            bind_back<quote<transform>, quote<push_back>>>;

    namespace lazy
    {
        
        
        template <typename ListOfLists>
        using transpose = defer<transpose, ListOfLists>;
    } 

    
    
    
    
    
    
    
    
    template <invocable Fn, list_like ListOfLists>
    using zip_with = transform<transpose<ListOfLists>, uncurry<Fn>>;

    namespace lazy
    {
        
        
        template <typename Fn, typename ListOfLists>
        using zip_with = defer<zip_with, Fn, ListOfLists>;
    } 

    
    
    
    
    
    
    
    
    template <list_like ListOfLists>
    using zip = transpose<ListOfLists>;

    namespace lazy
    {
        
        
        template <typename ListOfLists>
        using zip = defer<zip, ListOfLists>;
    } 

    
    
    
    namespace detail
    {
        template <typename T>
        using uncvref_t = _t<std::remove_cv<_t<std::remove_reference<T>>>>;

        
        
        template <typename Sequence>
        struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
        {
        };
    } 
    

    
    
    
    template <typename Sequence>
    using as_list = _t<detail::as_list_<detail::uncvref_t<Sequence>>>;

    namespace lazy
    {
        
        
        template <typename Sequence>
        using as_list = defer<as_list, Sequence>;
    } 

    
    
    
    namespace detail
    {
        template <typename L, typename State = list<>>
        struct reverse_ : lazy::fold<L, State, quote<push_front>>
        {
        };

        template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
                    typename T6, typename T7, typename T8, typename T9, typename... Ts,
                    typename... Us>
        struct reverse_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>, list<Us...>>
          : reverse_<list<Ts...>, list<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0, Us...>>
        {
        };
    }
    

    
    
    
    
    template <list_like L>
    using reverse = _t<detail::reverse_<L>>;

    namespace lazy
    {
        
        
        template <typename L>
        using reverse = defer<reverse, L>;
    } 

    
    
    template <invocable Fn>
    using not_fn = compose<quote<not_>, Fn>;

    namespace lazy
    {
        
        
        template <typename Fn>
        using not_fn = defer<not_fn, Fn>;
    } 

    
    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using all_of = empty<find_if<L, not_fn<Fn>>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using all_of = defer<all_of, L, Fn>;
    } 

    
    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using any_of = not_<empty<find_if<L, Fn>>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using any_of = defer<any_of, L, Fn>;
    } 

    
    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using none_of = empty<find_if<L, Fn>>;

    namespace lazy
    {
        
        
        template <typename L, invocable Fn>
        using none_of = defer<none_of, L, Fn>;
    } 

    
    
    
    
    
    
    
    template <list_like L, typename T>
    using in = not_<empty<find<L, T>>>;

    namespace lazy
    {
        
        
        template <typename L, typename T>
        using in = defer<in, L, T>;
    } 

    
    
    
    namespace detail
    {
        template <typename L>
        struct inherit_
        {
        };

        template <typename... L>
        struct inherit_<list<L...>> : L...
        {
            using type = inherit_;
        };
    } 
    

    
    
    
    
    template <list_like L>
    using inherit = meta::_t<detail::inherit_<L>>;

    namespace lazy
    {
        
        
        template <typename L>
        using inherit = defer<inherit, L>;
    } 

    
    
    
    namespace detail
    {
        template <typename Set, typename T>
        struct in_
        {
        };

        template <typename... Set, typename T>
        struct in_<list<Set...>, T> : bool_<__is_base_of(id<T>, inherit<list<id<Set>...>>)>
        {
        };

        template <typename Set, typename T>
        struct insert_back_
        {
        };

        template <typename... Set, typename T>
        struct insert_back_<list<Set...>, T>
        {
            using type = if_<in_<list<Set...>, T>, list<Set...>, list<Set..., T>>;
        };
    } 
    

    
    
    
    
    template <list_like L>
    using unique = fold<L, list<>, quote_trait<detail::insert_back_>>;

    namespace lazy
    {
        
        
        template <typename L>
        using unique = defer<unique, L>;
    } 

    
    
    
    namespace detail
    {
        template <typename Fn>
        struct partition_
        {

            template <typename, typename>


#line 3180 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct impl
            {
            };
            template <typename... Yes, typename... No, typename A>

            requires integral<invoke<Fn, A>>
            struct impl<pair<list<Yes...>, list<No...>>, A>



#line 3191 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            {
                using type = if_<meta::invoke<Fn, A>, pair<list<Yes..., A>, list<No...>>,
                                    pair<list<Yes...>, list<No..., A>>>;
            };

            template <typename State, typename A>
            using invoke = _t<impl<State, A>>;
        };
    } 
    

    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using partition = fold<L, pair<list<>, list<>>, detail::partition_<Fn>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using partition = defer<partition, L, Fn>;
    } 

    
    
    
    namespace detail
    {
        template <invocable Fn, typename A, typename B, typename... Ts>
        using part_ = partition<list<B, Ts...>, bind_back<Fn, A>>;

        template <typename L, typename Fn>
            requires list_like<L> && invocable<Fn>


#line 3232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        struct sort_
        {
        };
        template <typename Fn>
        struct sort_<list<>, Fn>
        {
            using type = list<>;
        };

        template <typename A, typename Fn>
        struct sort_<list<A>, Fn>
        {
            using type = list<A>;
        };

        template <typename A, typename B, typename... Ts, typename Fn>

            requires trait<sort_<first<part_<Fn, A, B, Ts...>>, Fn>> &&
                trait<sort_<second<part_<Fn, A, B, Ts...>>, Fn>>
        struct sort_<list<A, B, Ts...>, Fn>




#line 3257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        {
            using P = part_<Fn, A, B, Ts...>;
            using type = concat<_t<sort_<first<P>, Fn>>, list<A>, _t<sort_<second<P>, Fn>>>;
        };
    } 
    

    
    
    
    
    
    
    
    
    
    
    
    
    template <list_like L, invocable Fn>
    using sort = _t<detail::sort_<L, Fn>>;

    namespace lazy
    {
        
        
        template <typename L, typename Fn>
        using sort = defer<sort, L, Fn>;
    } 

    
    
    
    namespace detail
    {
        template <typename T, int = 0>
        struct protect_;

        template <typename, int = 0>
        struct vararg_;

        template <typename T, int = 0>
        struct is_valid_;

        
        template <typename If, typename... Ts>

        using lazy_if_ = lazy::_t<defer<_if_, If, protect_<Ts>...>>;


#line 3308 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

        template <typename A, typename T, typename Fn, typename Ts>
        struct subst1_
        {
            using type = list<list<T>>;
        };
        template <typename T, typename Fn, typename Ts>
        struct subst1_<Fn, T, Fn, Ts>
        {
            using type = list<>;
        };
        template <typename A, typename T, typename Fn, typename Ts>
        struct subst1_<vararg_<A>, T, Fn, Ts>
        {
            using type = list<Ts>;
        };

        template <typename As, typename Ts>
        using substitutions_ = push_back<
            join<transform<
                concat<As, repeat_n_c<size<Ts>{} + 2 - size<As>{}, back<As>>>,
                concat<Ts, repeat_n_c<2, back<As>>>,
                bind_back<quote_trait<subst1_>, back<As>, drop_c<Ts, size<As>{} - 2>>>>,
            list<back<As>>>;





#line 3338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        template <typename As, typename Ts>
        using substitutions =




            invoke<if_c<(size<Ts>{} + 2 >= size<As>{}), quote<substitutions_>>, As, Ts>;
#line 3346 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
#line 3347 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

        template <typename T>
        struct is_vararg_ : std::false_type
        {
        };
        template <typename T>
        struct is_vararg_<vararg_<T>> : std::true_type
        {
        };

        template <list_like Tags>
        using is_variadic_ = is_vararg_<at<push_front<Tags, void>, dec<size<Tags>>>>;

        template <list_like Tags, bool IsVariadic = is_variadic_<Tags>::value>
        struct lambda_;

        
        template <typename... As>
        struct lambda_<list<As...>, false>
        {
        private:
            static constexpr std::size_t arity = sizeof...(As) - 1;
            using Tags = list<As...>; 
            using Fn = back<Tags>;
            template <typename T, list_like Args>
            struct impl;
            template <typename T, list_like Args>
            using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;


#line 3378 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            template <typename, typename, typename = void>
#line 3380 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct subst_
            {
            };
            template <template <typename...> class C, typename... Ts, typename Args>


#line 3387 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct subst_<defer<C, Ts...>, Args, void_<C<_t<impl<Ts, Args>>...>>>
#line 3389 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            {
                using type = C<_t<impl<Ts, Args>>...>;
            };
            template <typename T, template <T...> class C, T... Is, typename Args>


#line 3396 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
#line 3398 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            {
                using type = C<Is...>;
            };
            template <typename T, list_like Args>
            struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
                                lazy::at<Args, reverse_find_index<Tags, T>>, id<T>>
            {
            };
            template <typename T, typename Args>
            struct impl<protect_<T>, Args>
            {
                using type = T;
            };
            template <typename T, typename Args>
            struct impl<is_valid_<T>, Args>
            {
                using type = is_trait<impl<T, Args>>;
            };
            template <typename If, typename... Ts, typename Args>
            struct impl<defer<if_, If, Ts...>, Args> 
              : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
            {
            };
            template <typename B, typename... Bs, typename Args>
            struct impl<defer<and_, B, Bs...>, Args> 
              : impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
                     Args>
            {
            };
            template <typename B, typename... Bs, typename Args>
            struct impl<defer<or_, B, Bs...>, Args> 
              : impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
                     Args>
            {
            };
            template <template <typename...> class C, typename... Ts, typename Args>
            struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
            {
            };
            template <typename T, template <T...> class C, T... Is, typename Args>
            struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
            {
            };
            template <template <typename...> class C, typename... Ts, typename Args>
            struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
            {
            };
            template <typename... Ts, typename Args>
            struct impl<lambda_<list<Ts...>, false>, Args>
            {
                using type = compose<uncurry<lambda_<list<As..., Ts...>, false>>,
                                        curry<bind_front<quote<concat>, Args>>>;
            };
            template <typename... Bs, typename Args>
            struct impl<lambda_<list<Bs...>, true>, Args>
            {
                using type = compose<typename lambda_<list<As..., Bs...>, true>::thunk,
                                        bind_front<quote<concat>, transform<Args, quote<list>>>,
                                        curry<bind_front<quote<substitutions>, list<Bs...>>>>;
            };

        public:
            template <typename... Ts>

                requires (sizeof...(Ts) == arity) using invoke = _t<impl<Fn, list<Ts..., Fn>>>;


#line 3466 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
        };

        
        
        template <typename... As>
        struct lambda_<list<As...>, true>
        {
        private:
            template <list_like T, bool IsVar>
            friend struct lambda_;
            using Tags = list<As...>; 
            template <typename T, list_like Args>
            struct impl;
            template <list_like Args>
            using eval_impl_ = bind_back<quote_trait<impl>, Args>;
            template <typename T, list_like Args>
            using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
            template <template <typename...> class C, list_like Args,
                        list_like Ts>
            using try_subst_ = apply<quote<C>, join<transform<Ts, eval_impl_<Args>>>>;


#line 3489 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            template <typename, typename, typename = void>
#line 3491 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct subst_
            {
            };
            template <template <typename...> class C, typename... Ts, typename Args>


#line 3498 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct subst_<defer<C, Ts...>, Args, void_<try_subst_<C, Args, list<Ts...>>>>
#line 3500 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            {
                using type = list<try_subst_<C, Args, list<Ts...>>>;
            };
            template <typename T, template <T...> class C, T... Is, typename Args>


#line 3507 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
#line 3509 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            {
                using type = list<C<Is...>>;
            };
            template <typename T, list_like Args>
            struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
                                lazy::at<Args, reverse_find_index<Tags, T>>, id<list<T>>>
            {
            };
            template <typename T, typename Args>
            struct impl<protect_<T>, Args>
            {
                using type = list<T>;
            };
            template <typename T, typename Args>
            struct impl<is_valid_<T>, Args>
            {
                using type = list<is_trait<impl<T, Args>>>;
            };
            template <typename If, typename... Ts, typename Args>
            struct impl<defer<if_, If, Ts...>, Args> 
              : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
            {
            };
            template <typename B, typename... Bs, typename Args>
            struct impl<defer<and_, B, Bs...>, Args> 
              : impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
                     Args>
            {
            };
            template <typename B, typename... Bs, typename Args>
            struct impl<defer<or_, B, Bs...>, Args> 
              : impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
                     Args>
            {
            };
            template <template <typename...> class C, typename... Ts, typename Args>
            struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
            {
            };
            template <typename T, template <T...> class C, T... Is, typename Args>
            struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
            {
            };
            template <template <typename...> class C, typename... Ts, typename Args>
            struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
            {
            };
            template <typename... Bs, bool IsVar, typename Args>
            struct impl<lambda_<list<Bs...>, IsVar>, Args>
            {
                using type =
                    list<compose<typename lambda_<list<As..., Bs...>, true>::thunk,
                                    bind_front<quote<concat>, Args>,
                                    curry<bind_front<quote<substitutions>, list<Bs...>>>>>;
            };
            struct thunk
            {
                template <typename S, typename R = _t<impl<back<Tags>, S>>>

                    requires (_v<size<R>> == 1) using invoke = front<R>;


#line 3572 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
            };

        public:
            template <typename... Ts>
            using invoke = invoke<thunk, substitutions<Tags, list<Ts...>>>;
        };
    } 
    

    
    
    
    
    
    
    
    
    
    template <typename... Ts>

        requires (sizeof...(Ts) > 0) using lambda = detail::lambda_<list<Ts...>>;


#line 3596 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"

    
    
    
    
    template <typename T>
    using is_valid = detail::is_valid_<T>;

    
    
    
    template <typename T>
    using vararg = detail::vararg_<T>;

    
    
    
    
    template <typename T>
    using protect = detail::protect_<T>;

    
    
    
    
    template <typename Tag, typename Value>
    struct var;

    
    namespace detail
    {
        template <typename...>
        struct let_
        {
        };
        template <typename Fn>
        struct let_<Fn>
        {
            using type = lazy::invoke<lambda<Fn>>;
        };
        template <typename Tag, typename Value, typename... Rest>
        struct let_<var<Tag, Value>, Rest...>
        {
            using type = lazy::invoke<lambda<Tag, _t<let_<Rest...>>>, Value>;
        };
    } 
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    template <typename... As>
    using let = _t<_t<detail::let_<As...>>>;

    namespace lazy
    {
        
        
        template <typename... As>
        using let = defer<let, As...>;
    } 

    
    
    inline namespace placeholders
    {
        
        struct _a;
        struct _b;
        struct _c;
        struct _d;
        struct _e;
        struct _f;
        struct _g;
        struct _h;
        struct _i;

        
        using _args = vararg<void>;
        using _args_a = vararg<_a>;
        using _args_b = vararg<_b>;
        using _args_c = vararg<_c>;
    } 

    
    
    
    namespace detail
    {
        template <typename M2, typename M>
        struct cartesian_product_fn
        {
            template <typename X>
            struct lambda0
            {
                template <typename Xs>
                using lambda1 = list<push_front<Xs, X>>;
                using type = join<transform<M2, quote<lambda1>>>;
            };
            using type = join<transform<M, quote_trait<lambda0>>>;
        };
    } 
    

    
    
    
    
    
    
    template <list_like ListOfLists>
    using cartesian_product =
        reverse_fold<ListOfLists, list<list<>>, quote_trait<detail::cartesian_product_fn>>;

    namespace lazy
    {
        
        
        template <typename ListOfLists>
        using cartesian_product = defer<cartesian_product, ListOfLists>;
    } 

    
    
    
    namespace detail
    {
        template <bool>
        struct add_const_if
        {
            template <typename T>
            using invoke = T const;
        };
        template <>
        struct add_const_if<false>
        {
            template <typename T>
            using invoke = T;
        };
    } 
    template <bool If>
    using add_const_if_c = detail::add_const_if<If>;
    template <integral If>
    using add_const_if = add_const_if_c<If::type::value>;
    

    
    
    
    template <bool If, typename T>
    using const_if_c = typename add_const_if_c<If>::template invoke<T>;
    template <typename If, typename T>
    using const_if = typename add_const_if<If>::template invoke<T>;
    

    
    namespace detail
    {
        template <typename State, typename Ch>
        using atoi_ = if_c<(Ch::value >= '0' && Ch::value <= '9'),
                            std::integral_constant<typename State::value_type,
                                                    State::value * 10 + (Ch::value - '0')>>;
    }
    

    inline namespace literals
    {
        
        
        template <char... Chs>
        constexpr fold<list<char_<Chs>...>, meta::size_t<0>, quote<detail::atoi_>>
            operator"" _z()
        {
            return {};
        }
    } 
} 





















































































































































































#line 3967 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
#line 3968 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"





#line 3974 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\meta/meta.hpp"
#pragma external_header(pop)
#line 20 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"





















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"


























#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"











#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"




#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"
#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"









#line 58 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"




#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"








#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"






#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"






























#line 110 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"

namespace concepts
{
    
    namespace detail
    {
        template<typename T>
        inline constexpr bool is_movable_v =
            std::is_object<T>::value &&
            std::is_move_constructible<T>::value &&
            std::is_move_assignable<T>::value;

        template<typename T>
        struct static_const
        {
            static constexpr T const value {};
        };
        template<typename T>
        constexpr T const static_const<T>::value;
    }
    

    template<typename T>
    struct is_swappable;

    template<typename T>
    struct is_nothrow_swappable;

    template<typename T, typename U>
    struct is_swappable_with;

    template<typename T, typename U>
    struct is_nothrow_swappable_with;

    template<typename T, typename U = T>
    constexpr
    meta::if_c<
        std::is_move_constructible<T>::value &&
        std::is_assignable<T &, U>::value, T>
    exchange(T &t, U &&u)
        noexcept(
            std::is_nothrow_move_constructible<T>::value &&
            std::is_nothrow_assignable<T &, U>::value)
    {
        T tmp((T &&) t);
        t = (U &&) u;
        
        return tmp;
    }

    
    namespace adl_swap_detail
    {
        struct nope
        {};

        
        
        template<typename T>
        nope swap(T &, T &) = delete;

        template<typename T, std::size_t N>
        nope swap(T (&)[N], T (&)[N]) = delete;





        template<typename T, typename U>
        decltype(swap(std::declval<T>(), std::declval<U>())) try_adl_swap_(int);

        template<typename T, typename U>
        nope try_adl_swap_(long);

        template<typename T, typename U = T>
        inline constexpr bool is_adl_swappable_v =
            !std::is_same_v<decltype(adl_swap_detail::try_adl_swap_<T, U>(42)), nope>;

        struct swap_fn
        {
            
            template<typename T, typename U>
            constexpr
            meta::if_c<is_adl_swappable_v<T, U>>
            operator()(T &&t, U &&u) const
            noexcept(noexcept(swap((T &&) t, (U &&) u)))
            {
                swap((T &&) t, (U &&) u);
            }

            
            
            template<typename T>
            constexpr
            meta::if_c<
                !is_adl_swappable_v<T &> &&
                detail::is_movable_v<T>>
            operator()(T &a, T &b) const
            noexcept(noexcept(b = concepts::exchange(a, (T &&) b)))
            {
                b = concepts::exchange(a, (T &&) b);
            }

            
            
            
            template<typename T, typename U, std::size_t N>
            constexpr
            meta::if_c<
                !is_adl_swappable_v<T (&)[N], U (&)[N]> &&
                is_swappable_with<T &, U &>::value>
            operator()(T (&t)[N], U (&u)[N]) const
                noexcept(is_nothrow_swappable_with<T &, U &>::value)
            {
                for(std::size_t i = 0; i < N; ++i)
                    (*this)(t[i], u[i]);
            }

            
            
            
            template<typename F0, typename S0, typename F1, typename S1>
            constexpr
            meta::if_c<is_swappable_with<F0, F1>::value && is_swappable_with<S0, S1>::value>
            operator()(std::pair<F0, S0> &&left, std::pair<F1, S1> &&right) const
                noexcept(
                    is_nothrow_swappable_with<F0, F1>::value &&
                    is_nothrow_swappable_with<S0, S1>::value)
            {
                swap_fn()(static_cast<std::pair<F0, S0> &&>(left).first,
                            static_cast<std::pair<F1, S1> &&>(right).first);
                swap_fn()(static_cast<std::pair<F0, S0> &&>(left).second,
                            static_cast<std::pair<F1, S1> &&>(right).second);
            }

            template<typename ...Ts, typename ...Us>
            constexpr
            meta::if_c<meta::and_c<is_swappable_with<Ts, Us>::value...>::value>
            operator()(std::tuple<Ts...> &&left, std::tuple<Us...> &&right) const
                noexcept(meta::and_c<is_nothrow_swappable_with<Ts, Us>::value...>::value)
            {
                swap_fn::impl(
                    static_cast<std::tuple<Ts...> &&>(left),
                    static_cast<std::tuple<Us...> &&>(right),
                    meta::make_index_sequence<sizeof...(Ts)>{});
            }

        private:
            template<typename... Ts>
            static constexpr int ignore_unused(Ts &&...)
            {
                return 0;
            }
            template<typename T, typename U, std::size_t ...Is>
            constexpr
            static void impl(T &&left, U &&right, meta::index_sequence<Is...>)
            {
                (void) swap_fn::ignore_unused(
                    (swap_fn()(std::get<Is>(static_cast<T &&>(left)),
                                std::get<Is>(static_cast<U &&>(right))), 42)...);
            }
        };

        template<typename T, typename U, typename = void>
        struct is_swappable_with_
            : std::false_type
        {};

        template<typename T, typename U>
        struct is_swappable_with_<T, U, meta::void_<
            decltype(swap_fn()(std::declval<T>(), std::declval<U>())),
            decltype(swap_fn()(std::declval<U>(), std::declval<T>()))>>
            : std::true_type
        {};

        template<typename T, typename U>
        struct is_nothrow_swappable_with_
            : meta::bool_<noexcept(swap_fn()(std::declval<T>(), std::declval<U>())) &&
                        noexcept(swap_fn()(std::declval<U>(), std::declval<T>()))>
        {};

        
        
        
        
        
        

        
        
        
        

        
        
        
    }
    

    
    template<typename T, typename U>
    struct is_swappable_with
        : adl_swap_detail::is_swappable_with_<T, U>
    {};

    
    template<typename T, typename U>
    struct is_nothrow_swappable_with
        : meta::and_<
            is_swappable_with<T, U>,
            adl_swap_detail::is_nothrow_swappable_with_<T, U>>
    {};

    
    template<typename T>
    struct is_swappable
        : is_swappable_with<T &, T &>
    {};

    
    template<typename T>
    struct is_nothrow_swappable
        : is_nothrow_swappable_with<T &, T &>
    {};

    
    
    inline namespace _ { inline constexpr adl_swap_detail::swap_fn swap{}; }
}

#line 341 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/swap.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/type_traits.hpp"




















namespace concepts
{
    template<typename T>
    using remove_cvref_t =
        typename std::remove_cv<
            typename std::remove_reference<T>::type>::type;

    
    namespace detail
    {
        template<typename From, typename To>
        using is_convertible = std::is_convertible<meta::_t<std::add_rvalue_reference<From>>, To>;

        template<bool>
        struct if_else_
        {
            template<typename, typename U>
            using invoke = U;
        };
        template<>
        struct if_else_<true>
        {
            template<typename T, typename>
            using invoke = T;
        };
        template<bool B, typename T, typename U>
        using if_else_t = meta::invoke<if_else_<B>, T, U>;

        template<bool>
        struct if_
        {};
        template<>
        struct if_<true>
        {
            template<typename T>
            using invoke = T;
        };
        template<bool B, typename T = void>
        using if_t = meta::invoke<if_<B>, T>;

        template<typename From, typename To>
        struct _copy_cv_
        {
            using type = To;
        };
        template<typename From, typename To>
        struct _copy_cv_<From const, To>
        {
            using type = To const;
        };
        template<typename From, typename To>
        struct _copy_cv_<From volatile, To>
        {
            using type = To volatile;
        };
        template<typename From, typename To>
        struct _copy_cv_<From const volatile, To>
        {
            using type = To const volatile;
        };
        template<typename From, typename To>
        using _copy_cv = meta::_t<_copy_cv_<From, To>>;

        
        template<typename T, typename U, typename = void>
        struct _builtin_common;

        template<typename T, typename U>
        using _builtin_common_t = meta::_t<_builtin_common<T, U>>;

        template<typename T, typename U>
        using _cond_res = decltype(true ? std::declval<T>() : std::declval<U>());

        template<typename T, typename U, typename R = _builtin_common_t<T &, U &>>
        using _rref_res =
            if_else_t<std::is_reference<R>::value, meta::_t<std::remove_reference<R>> &&, R>;

        template<typename T, typename U>
        using _lref_res = _cond_res<_copy_cv<T, U> &, _copy_cv<U, T> &>;

        template<typename T>
        struct as_cref_
        {
            using type = T const &;
        };
        template<typename T>
        struct as_cref_<T &>
        {
            using type = T const &;
        };
        template<typename T>
        struct as_cref_<T &&>
        {
            using type = T const &;
        };
        template<>
        struct as_cref_<void>
        {
            using type = void;
        };
        template<>
        struct as_cref_<void const>
        {
            using type = void const;
        };

        template<typename T>
        using as_cref_t = typename as_cref_<T>::type;

        template<typename T>
        using decay_t = typename std::decay<T>::type;

    
        template<typename T, typename U, typename = void>
        struct _builtin_common_3
        {};
        template<typename T, typename U>
        struct _builtin_common_3<T, U, meta::void_<_cond_res<as_cref_t<T>, as_cref_t<U>>>>
            : std::decay<_cond_res<as_cref_t<T>, as_cref_t<U>>>
        {};
        template<typename T, typename U, typename = void>
        struct _builtin_common_2
            : _builtin_common_3<T, U>
        {};
        template<typename T, typename U>
        struct _builtin_common_2<T, U, meta::void_<_cond_res<T, U>>>
            : std::decay<_cond_res<T, U>>
        {};
        template<typename T, typename U, typename >
        struct _builtin_common
            : _builtin_common_2<T, U>
        {};
        template<typename T, typename U>
        struct _builtin_common<T &&, U &&, if_t<
            is_convertible<T &&, _rref_res<T, U>>::value &&
            is_convertible<U &&, _rref_res<T, U>>::value>>
        {
            using type = _rref_res<T, U>;
        };
        template<typename T, typename U>
        struct _builtin_common<T &, U &>
            : meta::defer<_lref_res, T, U>
        {};
        template<typename T, typename U>
        struct _builtin_common<T &, U &&, if_t<
            is_convertible<U &&, _builtin_common_t<T &, U const &>>::value>>
            : _builtin_common<T &, U const &>
        {};
        template<typename T, typename U>
        struct _builtin_common<T &&, U &>
            : _builtin_common<U &, T &&>
        {};
    























































#line 230 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/type_traits.hpp"
    }
    

    
    
    

    
    
    
    template<typename ...Ts>
    struct common_type
    {};

    template<typename T>
    struct common_type<T>
        : std::decay<T>
    {};

    template<typename T, typename U>
    struct common_type<T, U>
        : detail::if_else_t<
            (std::is_same_v<detail::decay_t<T>, T> &&
                std::is_same_v<detail::decay_t<U>, U> ),
            meta::defer<detail::_builtin_common_t, T, U>,
            common_type<detail::decay_t<T>, detail::decay_t<U>>>
    {};

    template<typename... Ts>
    using common_type_t = typename common_type<Ts...>::type;

    template<typename T, typename U, typename... Vs>
    struct common_type<T, U, Vs...>
        : meta::lazy::fold<meta::list<U, Vs...>, T, meta::quote<common_type_t>>
    {};

    

    
    
    

    
    
    template<
        typename T,
        typename U,
        template<typename> class TQual,
        template<typename> class UQual>
    struct basic_common_reference
    {};

    
    namespace detail
    {
        using _rref =
            meta::quote_trait<std::add_rvalue_reference>;
        using _lref =
            meta::quote_trait<std::add_lvalue_reference>;

        template<typename>
        struct _xref
        {
            template<typename T>
            using invoke = T;
        };
        template<typename T>
        struct _xref<T &&>
        {
            template<typename U>
            using invoke =
                meta::_t<std::add_rvalue_reference<meta::invoke<_xref<T>, U>>>;
        };
        template<typename T>
        struct _xref<T &>
        {
            template<typename U>
            using invoke =
                meta::_t<std::add_lvalue_reference<meta::invoke<_xref<T>, U>>>;
        };
        template<typename T>
        struct _xref<T const>
        {
            template<typename U>
            using invoke = U const;
        };
        template<typename T>
        struct _xref<T volatile>
        {
            template<typename U>
            using invoke = U volatile;
        };
        template<typename T>
        struct _xref<T const volatile>
        {
            template<typename U>
            using invoke = U const volatile;
        };

        template<typename T, typename U>
        using _basic_common_reference =
            basic_common_reference<
                remove_cvref_t<T>,
                remove_cvref_t<U>,
                _xref<T>::template invoke,
                _xref<U>::template invoke>;

        template<typename T, typename U, typename = void>
        struct _common_reference2
            : if_else_t<
                meta::is_trait<_basic_common_reference<T, U>>::value,
                _basic_common_reference<T, U>,
                common_type<T, U>>
        {};

        template<typename T, typename U>
        struct _common_reference2<T, U, if_t<std::is_reference<_builtin_common_t<T, U>>::value>>
            : _builtin_common<T, U>
        {};
    }
    

    
    
    template<typename ...Ts>
    struct common_reference
    {};

    template<typename T>
    struct common_reference<T>
    {
        using type = T;
    };

    template<typename T, typename U>
    struct common_reference<T, U>
        : detail::_common_reference2<T, U>
    {};

    template<typename... Ts>
    using common_reference_t = typename common_reference<Ts...>::type;

    template<typename T, typename U, typename... Vs>
    struct common_reference<T, U, Vs...>
        : meta::lazy::fold<meta::list<U, Vs...>, T, meta::quote<common_reference_t>>
    {};
    
} 

#line 380 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/type_traits.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"












#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"


#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"




#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"










#line 61 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"


#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
#line 65 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"


































#line 100 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
#line 101 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"












































































#line 178 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"



#line 182 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"















#line 198 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"












#line 211 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

#line 213 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"





#line 219 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

#line 221 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
































#line 254 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"


#line 257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"















#line 273 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"


















































































































































































#line 452 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
#line 453 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"








#line 462 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"





#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"



































#line 504 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"







#line 512 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"



































































































































#line 644 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

































































#line 710 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"




#line 715 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

namespace concepts
{
    template<bool B>
    using bool_ = std::integral_constant<bool, B>;


    template<bool...Bs>
    inline constexpr bool and_v = (Bs &&...);

    template<bool...Bs>
    inline constexpr bool or_v = (Bs ||...);














#line 742 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

    template<typename>
    struct return_t_
    {
        template<typename T>
        using invoke = T;
    };

    template<typename T, typename EnableIf>
    using return_t = meta::invoke<return_t_<EnableIf>, T>;

    
    namespace detail
    {
        struct ignore
        {
            template<class... Args>
            constexpr ignore(Args&&...) noexcept {}
        };

        template<class>
        constexpr bool true_()
        {
            return true;
        }

        template<typename...>
        struct tag;

        template<typename T>
        inline constexpr T instance_ = T{};

        template<typename>
        constexpr bool requires_()
        {
            return true;
        }

        struct Nil
        {};


        enum class xNil {};

        struct CPP_true_t
        {
            constexpr bool operator()(Nil) const noexcept
            {
                return true;
            }
            constexpr bool operator()(xNil) const noexcept
            {
                return true;
            }
        };

        inline constexpr CPP_true_t CPP_true_fn_ {};

        constexpr bool CPP_true_fn(xNil)
        {
            return true;
        }


#line 807 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

        constexpr bool CPP_true_fn(Nil)
        {
            return true;
        }
    } 
    


    template<bool B>
    std::enable_if_t<B> requires_()
    {}



#line 823 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

    inline namespace defs
    {
        
        
        

        
        
        template<bool B>
        concept is_true = B;

        
        
        template<typename... Args>
        concept type = true;

        
        
        template<class T, template<typename...> class Trait, typename... Args>
        concept satisfies =
            static_cast<bool>(Trait<T, Args...>::type::value);

        
        
        

        
        
        template<typename A, typename B>
        concept same_as =
            std::is_same_v<A, B> && std::is_same_v<B, A>;

        
        
        
        template<typename A, typename B>
        concept not_same_as_ =
            (!same_as<remove_cvref_t<A>, remove_cvref_t<B>>);
        

        
        
        
        
        
        
        template<typename From, typename To>
        concept implicitly_convertible_to =
            std::is_convertible<std::add_rvalue_reference_t<From>, To>::value;

        
        
        template<typename From, typename To>
        concept explicitly_convertible_to_requires_ = requires(From(*from)()) { static_cast<To>(from()); };
#line 882 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename From, typename To>
        concept explicitly_convertible_to =
            concepts::explicitly_convertible_to_requires_<From, To>;

        
        
        template<typename From, typename To>
        concept convertible_to =
            implicitly_convertible_to<From, To> &&
            explicitly_convertible_to<From, To>;

        
        
        template<typename T, typename U > concept derived_from_concept_ = convertible_to<T const volatile *, U const volatile *>;
#line 901 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept derived_from =
            __is_base_of(U, T) &&
            concepts::derived_from_concept_<T, U>;

        
        
        template<typename T, typename U > concept common_reference_with_concept_ = same_as<common_reference_t<T, U>, common_reference_t<U, T>> && convertible_to<T, common_reference_t<T, U>> && convertible_to<U, common_reference_t<T, U>>;
#line 916 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept common_reference_with =
            concepts::common_reference_with_concept_<T, U>;

        
        
        template<typename T, typename U > concept common_with_concept_ = same_as<common_type_t<T, U>, common_type_t<U, T>> && convertible_to<T, common_type_t<T, U>> && convertible_to<U, common_type_t<T, U>> && common_reference_with< std::add_lvalue_reference_t<T const>, std::add_lvalue_reference_t<U const>> && common_reference_with< std::add_lvalue_reference_t<common_type_t<T, U>>, common_reference_t< std::add_lvalue_reference_t<T const>, std::add_lvalue_reference_t<U const>>>;
#line 938 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept common_with =
            concepts::common_with_concept_<T, U>;

        
        
        template<typename T>
        concept integral =
            std::is_integral<T>::value;

        
        
        template<typename T>
        concept signed_integral =
            integral<T> &&
            std::is_signed<T>::value;

        
        
        template<typename T>
        concept unsigned_integral =
            integral<T> &&
            !signed_integral<T>;

        
        
        template<typename T, typename U>
        concept assignable_from_requires_ = requires(T t, U && u) { t = (U &&) u, requires_<same_as<T, decltype(t = (U &&) u)>>; };
#line 973 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept assignable_from =
            std::is_lvalue_reference<T>::value &&
            common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
            defs::assignable_from_requires_<T, U>;

        
        
        template<typename T>
        concept swappable_requires_ = requires(T & t, T & u) { concepts::swap(t, u); };
#line 989 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T>
        concept swappable =
            defs::swappable_requires_<T>;

        
        
        template<typename T, typename U>
        concept swappable_with_requires_ = requires(T && t, U && u) { concepts::swap((T &&) t, (T &&) t), concepts::swap((U &&) u, (U &&) u), concepts::swap((U &&) u, (T &&) t), concepts::swap((T &&) t, (U &&) u); };
#line 1006 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept swappable_with =
            common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
            defs::swappable_with_requires_<T, U>;

    }  

    namespace detail
    {
        
        
        template<typename T>
        concept boolean_testable_impl_ = convertible_to<T, bool>;

        
        
        template<typename T>
        concept boolean_testable_frag_requires_ = requires(T && t) { !(T&&) t, concepts::requires_<boolean_testable_impl_<decltype(!(T&&) t)>>; };
#line 1031 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

        
        
        template<typename T>
        concept boolean_testable_ =
            boolean_testable_frag_requires_<T> &&
            boolean_testable_impl_<T>;

        __pragma(warning(push))
        

        
        
        template<typename T, typename U>
        concept weakly_equality_comparable_with_frag_requires_ = requires(detail::as_cref_t<T> t, detail::as_cref_t<U> u) { concepts::requires_<boolean_testable_<decltype(t == u)>>, concepts::requires_<boolean_testable_<decltype(t != u)>>, concepts::requires_<boolean_testable_<decltype(u == t)>>, concepts::requires_<boolean_testable_<decltype(u != t)>>; };
#line 1053 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept weakly_equality_comparable_with_ =
            weakly_equality_comparable_with_frag_requires_<T, U>;

        
        
        template<typename T, typename U>
        concept partially_ordered_with_frag_requires_ = requires(detail::as_cref_t<T>& t, detail::as_cref_t<U>& u) { concepts::requires_<boolean_testable_<decltype(t < u)>>, concepts::requires_<boolean_testable_<decltype(t > u)>>, concepts::requires_<boolean_testable_<decltype(t <= u)>>, concepts::requires_<boolean_testable_<decltype(t >= u)>>, concepts::requires_<boolean_testable_<decltype(u < t)>>, concepts::requires_<boolean_testable_<decltype(u > t)>>, concepts::requires_<boolean_testable_<decltype(u <= t)>>, concepts::requires_<boolean_testable_<decltype(u >= t)>>; };
#line 1074 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept partially_ordered_with_ =
            partially_ordered_with_frag_requires_<T, U>;

        __pragma(warning(pop))
    } 

    inline namespace defs
    {
        
        
        

        
        
        template<typename T>
        concept equality_comparable =
            detail::weakly_equality_comparable_with_<T, T>;

        
        
        template<typename T, typename U > concept equality_comparable_with_concept_ = equality_comparable< common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>;
#line 1102 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T, typename U>
        concept equality_comparable_with =
            equality_comparable<T> &&
            equality_comparable<U> &&
            detail::weakly_equality_comparable_with_<T, U> &&
            common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
            concepts::equality_comparable_with_concept_<T, U>;

        
        
        template<typename T>
        concept totally_ordered =
            equality_comparable<T> &&
            detail::partially_ordered_with_<T, T>;

        
        
        template<typename T, typename U > concept totally_ordered_with_concept_ = totally_ordered< common_reference_t< detail::as_cref_t<T>, detail::as_cref_t<U>>> && detail::partially_ordered_with_<T, U>;
#line 1128 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"

        
        
        template<typename T, typename U>
        concept totally_ordered_with =
            totally_ordered<T> &&
            totally_ordered<U> &&
            equality_comparable_with<T, U> &&
            concepts::totally_ordered_with_concept_<T, U>;

        
        
        

        
        
        template<typename T>
        concept destructible =
            std::is_nothrow_destructible<T>::value;

        
        
        template<typename T, typename... Args>
        concept constructible_from =
            destructible<T> &&
            __is_constructible(T, Args...);

        
        
        template<typename T>
        concept default_constructible =
            constructible_from<T>;

        
        
        template<typename T>
        concept move_constructible =
            constructible_from<T, T> &&
            convertible_to<T, T>;

        
        
        template<typename T > concept copy_constructible_concept_ = constructible_from<T, T &> && constructible_from<T, T const &> && constructible_from<T, T const> && convertible_to<T &, T> && convertible_to<T const &, T> && convertible_to<T const, T>;
#line 1178 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T>
        concept copy_constructible =
            move_constructible<T> &&
            concepts::copy_constructible_concept_<T>;

        
        
        template<typename T > concept move_assignable_concept_ = assignable_from<T &, T>;
#line 1191 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T>
        concept movable =
            std::is_object<T>::value &&
            move_constructible<T> &&
            concepts::move_assignable_concept_<T> &&
            swappable<T>;

        
        
        template<typename T > concept copy_assignable_concept_ = assignable_from<T &, T const &>;
#line 1206 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
        
        
        template<typename T>
        concept copyable =
            copy_constructible<T> &&
            movable<T> &&
            concepts::copy_assignable_concept_<T>;

        
        
        template<typename T>
        concept semiregular =
            copyable<T> &&
            default_constructible<T>;
            
            

        
        
        template<typename T>
        concept regular =
            semiregular<T> &&
            equality_comparable<T>;

    } 
} 

#line 1234 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/concepts.hpp"
#pragma external_header(pop)
#line 23 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/compare.hpp"























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/compare.hpp"
























namespace ranges
{
   template<typename... Ts>
   struct common_comparison_category
   {
       using type = void;
   };

    template<typename... Ts>
    requires ((std::is_same_v<Ts, std::partial_ordering> ||
               std::is_same_v<Ts, std::weak_ordering> ||
               std::is_same_v<Ts, std::strong_ordering>) && ...)
    struct common_comparison_category<Ts...> : std::common_type<Ts...>
    {};

    template<typename... Ts>
    using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
} 

#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/compare.hpp"
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/compare.hpp"
#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/compare.hpp"



namespace concepts
{
    
    
    namespace detail
    {
        template<typename T, typename Cat>
        concept compares_as = same_as<ranges::common_comparison_category_t<T, Cat>, Cat>;
    } 

    inline namespace defs
    {
        template<typename T, typename Cat = std::partial_ordering>
        concept three_way_comparable =
            detail::weakly_equality_comparable_with_<T, T> &&
            detail::partially_ordered_with_<T ,T> &&
            requires(detail::as_cref_t<T>& a, detail::as_cref_t<T>& b) {
                { a <=> b } -> detail::compares_as<Cat>;
            };

        template<typename T, typename U, typename Cat = std::partial_ordering>
        concept three_way_comparable_with =
            three_way_comparable<T, Cat> &&
            three_way_comparable<U, Cat> &&
            common_reference_with<detail::as_cref_t<T>&, detail::as_cref_t<U>&> &&
            three_way_comparable<common_reference_t<detail::as_cref_t<T>&, detail::as_cref_t<U>&>> &&
            detail::partially_ordered_with_<T, U> &&
            requires(detail::as_cref_t<T>& t, detail::as_cref_t<U>& u) {
                { t <=> u } -> detail::compares_as<Cat>;
                { u <=> t } -> detail::compares_as<Cat>;
            };
    } 
} 



#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/compare.hpp"
#line 67 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\concepts/compare.hpp"
#pragma external_header(pop)
#line 24 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"




















#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\version"





#pragma once



#line 11 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\version"
#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 25 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





namespace ranges
{
    namespace detail
    {
        template<typename = void>
        [[noreturn]] void assert_failure(char const * file, int line, char const * msg)
        {
            std::fprintf((__acrt_iob_func(2)), "%s(%d): %s\n", file, line, msg);
            std::abort();
        }
    } 
} 

#line 48 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"














#line 65 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 73 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 77 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 78 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 85 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"







#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 96 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 101 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






























































































































#line 228 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
































#line 261 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 265 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


                                      

                                      

                                      

                                      


                                      

                                      

                                      


#line 284 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"




#line 289 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"











































































































#line 397 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


















#line 416 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 423 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 431 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 432 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





#line 440 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"








#line 449 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 450 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 457 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 458 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 465 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 466 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"







#line 474 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 475 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 482 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 483 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 490 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 491 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"




#line 496 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 500 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 502 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 503 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





#line 509 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 514 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 515 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"












#line 528 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 531 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"















#line 547 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 550 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 551 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





#line 557 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"











#line 569 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 570 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"








#line 580 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"




#line 585 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





#line 591 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 598 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"







#line 606 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





#line 612 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"














#line 627 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"















#line 643 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"





#line 649 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 653 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 654 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"









#line 664 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 665 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 672 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 673 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"








#line 684 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 687 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 688 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 692 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 694 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 698 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"




#line 704 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 706 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"








#line 715 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 717 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"







#line 725 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 726 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"



#line 731 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 734 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"









#line 744 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 746 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"


#line 749 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 750 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"






#line 757 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#line 758 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"

#line 760 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/config.hpp"
#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/static_const.hpp"















namespace ranges
{
    

    template<typename T>
    struct static_const
    {
        static constexpr T value{};
    };

    
    
    template<typename T>
    constexpr T static_const<T>::value;
} 

#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/static_const.hpp"
#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/version.hpp"























#line 25 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/version.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"















#line 17 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 62 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

__pragma(warning(push))


namespace ranges
{
    
    namespace views
    {
    }

    namespace actions
    {
    }











#line 88 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
    inline namespace [[deprecated("The name ranges::v3 namespace is deprecated. " "Please discontinue using it.")]] v3
#line 91 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
    {
        using namespace ranges;
    }

    namespace [[deprecated("The ranges::view namespace has been renamed to ranges::views. " "(Sorry!)")]] view
#line 98 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
    {
        using namespace views;
    }

    namespace [[deprecated("The ranges::action namespace has been renamed to ranges::actions. " "(Sorry!)")]] action
#line 105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
    {
        using namespace actions;
    }
#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

    namespace _end_
    {
        struct fn;
    }
    using end_fn = _end_::fn;

    namespace _size_
    {
        struct fn;
    }

    template<typename>
    struct result_of;

    template<typename Sig>
    using result_of_t [[deprecated("ranges::result_of_t is deprecated. " "Please use ranges::invoke_result_t")]] = meta::_t<result_of<Sig>>;
#line 128 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
    

    template<typename...>
    struct variant;

    struct dangling;

    struct make_pipeable_fn;

    struct pipeable_base;

    template<typename First, typename Second>
    struct composed;

    template<typename... Fns>
    struct overloaded;

    namespace actions
    {
        template<typename ActionFn>
        struct action_closure;
    }

    namespace views
    {
        template<typename ViewFn>
        struct view_closure;
    }

    struct advance_fn;

    struct advance_to_fn;

    struct advance_bounded_fn;

    struct next_fn;

    struct prev_fn;

    struct distance_fn;

    struct iter_size_fn;

    template<typename T>
    struct indirectly_readable_traits;

    template<typename T>
    using readable_traits [[deprecated("Please use ranges::indirectly_readable_traits")]]
     = indirectly_readable_traits<T>;

    template<typename T>
    struct incrementable_traits;

    struct view_base
    {};

    
    namespace detail
    {
        template<typename T>
        struct difference_type_;

        template<typename T>
        struct value_type_;
    } 

    template<typename T>
    using difference_type [[deprecated("ranges::difference_type<T>::type is deprecated. Use " "ranges::incrementable_traits<T>::difference_type instead.")]] =
#line 198 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
        detail::difference_type_<T>;

    template<typename T>
    using value_type [[deprecated("ranges::value_type<T>::type is deprecated. Use " "ranges::indirectly_readable_traits<T>::value_type instead.")]] = detail::value_type_<T>;
#line 204 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

    template<typename T>
    struct size_type;
    

    
    namespace detail
    {
        struct ignore_t
        {
            ignore_t() = default;
            template<typename T>
            constexpr ignore_t(T &&) noexcept
            {}
            template<typename T>
            constexpr ignore_t const & operator=(T &&) const noexcept
            {
                return *this;
            }
        };

        struct value_init
        {
            template<typename T>
            operator T() const
            {
                return T{};
            }
        };

        struct make_compressed_pair_fn;

        template<typename T>
        constexpr meta::_t<std::remove_reference<T>> && move(T && t) noexcept
        {
            return static_cast<meta::_t<std::remove_reference<T>> &&>(t);
        }

        struct as_const_fn
        {
            template<typename T>
            constexpr T const & operator()(T & t) const noexcept
            {
                return t;
            }
            template<typename T>
            constexpr T const && operator()(T && t) const noexcept
            {
                return (T &&) t;
            }
        };

        inline constexpr as_const_fn as_const{};

        template<typename T>
        using as_const_t = decltype(as_const(std::declval<T>()));

        template<typename T>
        using decay_t = meta::_t<std::decay<T>>;

        template<typename T, typename R = meta::_t<std::remove_reference<T>>>
        using as_ref_t =
            meta::_t<std::add_lvalue_reference<meta::_t<std::remove_const<R>>>>;

        template<typename T, typename R = meta::_t<std::remove_reference<T>>>
        using as_cref_t = meta::_t<std::add_lvalue_reference<R const>>;

        struct get_first;
        struct get_second;

        template<typename Val1, typename Val2>
        struct replacer_fn;

        template<typename Pred, typename Val>
        struct replacer_if_fn;

        template<typename I>
        struct move_into_cursor;

        template<typename Int>
        struct from_end_;

        template<typename... Ts>
        constexpr int ignore_unused(Ts &&...)
        {
            return 42;
        }

        template<int I>
        struct priority_tag : priority_tag<I - 1>
        {};

        template<>
        struct priority_tag<0>
        {};



























































#line 359 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
        using std::is_trivially_constructible;
        using std::is_trivially_default_constructible;
        using std::is_trivially_copy_assignable;
        using std::is_trivially_copy_constructible;
        using std::is_trivially_copyable;
        using std::is_trivially_assignable;
        using std::is_trivially_move_assignable;
        using std::is_trivially_move_constructible;

        using std::is_trivially_constructible_v;
        using std::is_trivially_default_constructible_v;
        using std::is_trivially_copy_assignable_v;
        using std::is_trivially_copy_constructible_v;
        using std::is_trivially_copyable_v;
        using std::is_trivially_assignable_v;
        using std::is_trivially_move_assignable_v;
        using std::is_trivially_move_constructible_v;

























#line 402 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
#line 403 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

        template<typename T>
        inline constexpr bool is_trivial_v =
            is_trivially_copyable_v<T> &&
            is_trivially_default_constructible_v<T>;

        template<typename T>
        struct is_trivial
          : meta::bool_<is_trivial_v<T>>
        {};










#line 424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
        using std::is_final;

        using std::is_final_v;



#line 431 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
#line 432 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"






#line 439 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

        
        
        template<typename T>
        char (&is_function_impl_(priority_tag<0>))[1];

        
        template<typename T, typename = decltype((*(T *)0)[0])>
        char (&is_function_impl_(priority_tag<1>))[2];

        
        
        template<typename T, typename = T (*)()>
        char (&is_function_impl_(priority_tag<2>))[3];

        
        template<typename T, typename = int T::*>
        char (&is_function_impl_(priority_tag<3>))[4];

        template<typename T>
        inline constexpr bool is_function_v =
            sizeof(detail::is_function_impl_<T>(priority_tag<3>{})) == 1;

        template<typename T>
        struct remove_rvalue_reference
        {
            using type = T;
        };

        template<typename T>
        struct remove_rvalue_reference<T &&>
        {
            using type = T;
        };

        template<typename T>
        using remove_rvalue_reference_t = meta::_t<remove_rvalue_reference<T>>;

        
        
        
        
        template<typename From, typename To>
        using is_convertible =
            std::is_convertible<meta::_t<std::add_rvalue_reference<From>>, To>;
    } 
    

    struct begin_tag
    {};
    struct end_tag
    {};
    struct copy_tag
    {};
    struct move_tag
    {};

    template<typename T>
    using uncvref_t = meta::_t<std::remove_cv<meta::_t<std::remove_reference<T>>>>;

    struct not_equal_to;
    struct equal_to;
    struct less;

    struct compare_three_way;
#line 506 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
    struct identity;
    template<typename Pred>
    struct logical_negate;

    enum cardinality : std::ptrdiff_t
    {
        infinite = -3,
        unknown = -2,
        finite = -1
    };

    template<typename Rng, typename Void = void>
    struct range_cardinality;

    template<typename Rng>
    using is_finite = meta::bool_<range_cardinality<Rng>::value >= finite>;

    template<typename Rng>
    using is_infinite = meta::bool_<range_cardinality<Rng>::value == infinite>;

    template<typename S, typename I>
    inline constexpr bool disable_sized_sentinel = false;

    template<typename R>
    inline constexpr bool enable_borrowed_range = false;

    namespace detail
    {
        template<typename R>
        [[deprecated("Please use ranges::enable_borrowed_range instead.")]]
        inline constexpr bool enable_safe_range = enable_borrowed_range<R>;
    } 

    using detail::enable_safe_range;

    template<typename Cur>
    struct basic_mixin;

    template<typename Cur>
    struct __declspec(empty_bases) basic_iterator;

    template<cardinality>
    struct basic_view : view_base
    {};

    template<typename Derived, cardinality C = finite>
    struct view_facade;

    template<typename Derived, typename BaseRng,
             cardinality C = range_cardinality<BaseRng>::value>
    struct view_adaptor;

    template<typename I, typename S>
    struct common_iterator;

    
    namespace detail
    {
        template<typename I>
        struct cpp17_iterator_cursor;

        template<typename I>
        using cpp17_iterator = basic_iterator<cpp17_iterator_cursor<I>>;
    } 
    

    template<typename First, typename Second>
    struct compressed_pair;

    template<typename T>
    struct bind_element;

    template<typename T>
    using bind_element_t = meta::_t<bind_element<T>>;

    template<typename Derived, cardinality = finite>
    struct view_interface;

    template<typename T>
    struct istream_view;

    template<typename I, typename S = I>
    struct __declspec(empty_bases) iterator_range;

    template<typename I, typename S = I>
    struct sized_iterator_range;

    template<typename T>
    struct reference_wrapper;

    
    
    template<typename Rng, typename Pred>
    struct __declspec(empty_bases) adjacent_filter_view;

    namespace views
    {
        struct adjacent_filter_fn;
    }

    template<typename Rng, typename Pred>
    struct __declspec(empty_bases) adjacent_remove_if_view;

    namespace views
    {
        struct adjacent_remove_if_fn;
    }

    namespace views
    {
        struct all_fn;
    }


    template<typename Rng, typename Fun>
    struct chunk_by_view;

    namespace views
    {
        struct chunk_by_fn;
    }

    template<typename Rng>
    struct const_view;

    namespace views
    {
        struct const_fn;
    }

    template<typename I>
    struct counted_view;

    namespace views
    {
        struct counted_fn;
    }

    struct default_sentinel_t;

    template<typename I>
    struct move_iterator;

    template<typename I>
    using move_into_iterator = basic_iterator<detail::move_into_cursor<I>>;

    template<typename Rng, bool = (bool)is_infinite<Rng>()>
    struct __declspec(empty_bases) cycled_view;

    namespace views
    {
        struct cycle_fn;
    }

    
    namespace detail
    {
        template<typename I>
        struct reverse_cursor;
    }
    

    template<typename I>
    using reverse_iterator = basic_iterator<detail::reverse_cursor<I>>;

    template<typename T>
    struct empty_view;

    namespace views
    {
        struct empty_fn;
    }

    template<typename Rng, typename Fun>
    struct group_by_view;

    namespace views
    {
        struct group_by_fn;
    }

    template<typename Rng>
    struct indirect_view;

    namespace views
    {
        struct indirect_fn;
    }

    struct unreachable_sentinel_t;

    template<typename From, typename To = unreachable_sentinel_t>
    struct iota_view;

    template<typename From, typename To = From>
    struct closed_iota_view;

    namespace views
    {
        struct iota_fn;
        struct closed_iota_fn;
    } 

    template<typename Rng>
    struct join_view;

    template<typename Rng, typename ValRng>
    struct join_with_view;

    namespace views
    {
        struct join_fn;
    }

    template<typename... Rngs>
    struct concat_view;

    namespace views
    {
        struct concat_fn;
    }

    template<typename Rng, typename Fun>
    struct partial_sum_view;

    namespace views
    {
        struct partial_sum_fn;
    }

    template<typename Rng>
    struct move_view;

    namespace views
    {
        struct move_fn;
    }

    template<typename Rng>
    struct ref_view;

    namespace views
    {
        struct ref_fn;
    }

    template<typename Val>
    struct repeat_view;

    namespace views
    {
        struct repeat_fn;
    }

    template<typename Rng>
    struct __declspec(empty_bases) reverse_view;

    namespace views
    {
        struct reverse_fn;
    }

    template<typename Rng>
    struct slice_view;

    namespace views
    {
        struct slice_fn;
    }

    
    

    
    
    
    

    template<typename Rng>
    struct single_view;

    namespace views
    {
        struct single_fn;
    }

    template<typename Rng>
    struct stride_view;

    namespace views
    {
        struct stride_fn;
    }

    template<typename Rng>
    struct take_view;

    namespace views
    {
        struct take_fn;
    }

    
    namespace detail
    {
        template<typename Rng>
        struct is_random_access_common_;

        template<typename Rng,
                 bool IsRandomAccessCommon = is_random_access_common_<Rng>::value>
        struct take_exactly_view_;
    } 
    

    template<typename Rng>
    using take_exactly_view = detail::take_exactly_view_<Rng>;

    namespace views
    {
        struct take_exactly_fn;
    }

    template<typename Rng, typename Pred>
    struct iter_take_while_view;

    template<typename Rng, typename Pred>
    struct take_while_view;

    namespace views
    {
        struct iter_take_while_fn;
        struct take_while_fn;
    } 

    template<typename Rng, typename Regex, typename SubMatchRange>
    struct tokenize_view;

    namespace views
    {
        struct tokenize_fn;
    }

    template<typename Rng, typename Fun>
    struct iter_transform_view;

    template<typename Rng, typename Fun>
    struct transform_view;

    namespace views
    {
        struct transform_fn;
    }

    template<typename Rng, typename Val1, typename Val2>
    using replace_view = iter_transform_view<Rng, detail::replacer_fn<Val1, Val2>>;

    template<typename Rng, typename Pred, typename Val>
    using replace_if_view = iter_transform_view<Rng, detail::replacer_if_fn<Pred, Val>>;

    namespace views
    {
        struct replace_fn;

        struct replace_if_fn;
    } 

    template<typename Rng, typename Pred>
    struct trim_view;

    namespace views
    {
        struct trim_fn;
    }

    template<typename I>
    struct unbounded_view;

    namespace views
    {
        struct unbounded_fn;
    }

    template<typename Rng>
    using unique_view = adjacent_filter_view<Rng, logical_negate<equal_to>>;

    namespace views
    {
        struct unique_fn;
    }

    template<typename Rng>
    using keys_range_view = transform_view<Rng, detail::get_first>;

    template<typename Rng>
    using values_view = transform_view<Rng, detail::get_second>;

    namespace views
    {
        struct keys_fn;

        struct values_fn;
    } 

    template<typename Fun, typename... Rngs>
    struct iter_zip_with_view;

    template<typename Fun, typename... Rngs>
    struct zip_with_view;

    template<typename... Rngs>
    struct zip_view;

    namespace views
    {
        struct iter_zip_with_fn;

        struct zip_with_fn;

        struct zip_fn;
    } 
} 


namespace ranges
{
    namespace concepts = ::concepts;
    using namespace ::concepts::defs;
    using ::concepts::and_v;
} 


__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 940 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"

#line 942 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range_fwd.hpp"
#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"






















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

























#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

#pragma external_header(push)
#line 1 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string_view"





#pragma once







#line 15 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string_view"

#line 17 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string_view"
#line 18 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string_view"
#line 19 "\\vcfs\\Archive\\msvc\\fe\\20230714.02\\binaries.amd64ret\\inc\\string_view"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"







#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"




















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"

namespace ranges
{
    
    
    struct equal_to
    {
         template<typename T, typename U > requires equality_comparable_with<T, U>
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr bool operator()(T && t, U && u) const
        {
            return (T &&) t == (U &&) u;
        }
        using is_transparent = void;
    };

    struct not_equal_to
    {
         template<typename T, typename U > requires equality_comparable_with<T, U>
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr bool operator()(T && t, U && u) const
        {
            return !equal_to{}((T &&) t, (U &&) u);
        }
        using is_transparent = void;
    };

    struct less
    {
         template<typename T, typename U > requires totally_ordered_with<T, U>
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr bool operator()(T && t, U && u) const
        {
            return (T &&) t < (U &&) u;
        }
        using is_transparent = void;
    };

    struct less_equal
    {
         template<typename T, typename U > requires totally_ordered_with<T, U>
#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr bool operator()(T && t, U && u) const
        {
            return !less{}((U &&) u, (T &&) t);
        }
        using is_transparent = void;
    };

    struct greater_equal
    {
         template<typename T, typename U > requires totally_ordered_with<T, U>
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr bool operator()(T && t, U && u) const
        {
            return !less{}((T &&) t, (U &&) u);
        }
        using is_transparent = void;
    };

    struct greater
    {
         template<typename T, typename U > requires totally_ordered_with<T, U>
#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr bool operator()(T && t, U && u) const
        {
            return less{}((U &&) u, (T &&) t);
        }
        using is_transparent = void;
    };

    using ordered_less [[deprecated("Repace uses of ranges::ordered_less with ranges::less")]] = less;
#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"


    struct compare_three_way
    {
         template<typename T, typename U > requires three_way_comparable_with<T, U>
#line 102 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
        constexpr auto operator()(T && t, U && u) const
            -> decltype((T &&) t <=> (U &&) u)
        {
            return (T &&) t <=> (U &&) u;
        }

        using is_transparent = void;
    };
#line 111 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"

    namespace cpp20
    {
        using ranges::equal_to;
        using ranges::greater;
        using ranges::greater_equal;
        using ranges::less;
        using ranges::less_equal;
        using ranges::not_equal_to;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"

#line 127 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/comparisons.hpp"
#pragma external_header(pop)
#line 39 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"


















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"



























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"

__pragma(warning(push))

__pragma(warning(disable : 4068)) __pragma(warning(disable : 4996))






#line 40 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        __pragma(warning(push))
        

        template<typename U>
        U & can_reference_(U &&);

        
        
        
        template<typename T>
        concept dereferenceable_part_requires_ = requires(T && t) { detail::can_reference_(*(T &&) t); };
#line 65 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
        
        
        template<typename T>
        concept dereferenceable_ = 
            detail::dereferenceable_part_requires_<T>;
        

        __pragma(warning(pop))

        template<typename T>
        inline constexpr bool is_reference_wrapper_v =
            meta::is<T, reference_wrapper>::value ||
            meta::is<T, std::reference_wrapper>::value;
    } 
    

    template<typename T>
    inline constexpr bool is_reference_wrapper_v =
        detail::is_reference_wrapper_v<detail::decay_t<T>>;

    template<typename T>
    using is_reference_wrapper = meta::bool_<is_reference_wrapper_v<T>>;

    
    template<typename T>
    using is_reference_wrapper_t [[deprecated("is_reference_wrapper_t is deprecated.")]] = meta::_t<is_reference_wrapper<T>>;
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
    

    struct invoke_fn
    {
    private:
         template<typename, typename T1 > requires detail::dereferenceable_<T1>
#line 99 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
        static constexpr decltype(auto) coerce(T1 && t1, long)
            noexcept(noexcept(*static_cast<T1 &&>(t1)))
        {
            return *static_cast<T1 &&>(t1);
        }

         template<typename T, typename T1 > requires derived_from<detail::decay_t<T1>, T>
#line 107 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
        static constexpr T1 && coerce(T1 && t1, int) noexcept
        {
            return static_cast<T1 &&>(t1);
        }

         template<typename, typename T1 > requires detail::is_reference_wrapper_v<detail::decay_t<T1>>
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
        static constexpr decltype(auto) coerce(T1 && t1, int) noexcept
        {
            return static_cast<T1 &&>(t1).get();
        }

    public:
        template<typename F, typename T, typename T1, typename... Args>
        constexpr auto operator()(F T::*f, T1&& t1, Args&&... args) const
            noexcept(noexcept((invoke_fn::coerce<T>((T1&&) t1, 0).*f)((Args&&) args...)))
            -> decltype((invoke_fn::coerce<T>((T1&&) t1, 0).*f)((Args&&) args...))
        {
            return (invoke_fn::coerce<T>((T1&&) t1, 0).*f)((Args&&) args...);
        }

        template<typename D, typename T, typename T1>
        constexpr auto operator()(D T::*f, T1&& t1) const
            noexcept(noexcept(invoke_fn::coerce<T>((T1&&) t1, 0).*f))
            -> decltype(invoke_fn::coerce<T>((T1&&) t1, 0).*f)
        {
            return invoke_fn::coerce<T>((T1&&) t1, 0).*f;
        }

        template<typename F, typename... Args>
        constexpr
        auto operator()(F&& f, Args&&... args) const
            noexcept(noexcept(((F&&) f)((Args&&) args...)))
            -> decltype(((F&&) f)((Args&&) args...))
        {
            return ((F&&) f)((Args&&) args...);
        }
    };

    inline constexpr invoke_fn invoke{};


    
    namespace detail
    {
        template<typename Void, typename Fun, typename... Args>
        struct _invoke_result_
        {};

        template<typename Fun, typename... Args>
        struct _invoke_result_<
            meta::void_<decltype(invoke(std::declval<Fun>(), std::declval<Args>()...))>,
            Fun, Args...>
        {
            using type = decltype(invoke(std::declval<Fun>(), std::declval<Args>()...));
        };
    } 
    

    template<typename Fun, typename... Args>
    using invoke_result = detail::_invoke_result_<void, Fun, Args...>;

    template<typename Fun, typename... Args>
    using invoke_result_t = meta::_t<invoke_result<Fun, Args...>>;









#line 181 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"

    
    namespace detail
    {
        template<bool IsInvocable>
        struct is_nothrow_invocable_impl_
        {
            template<typename Fn, typename... Args>
            static constexpr bool apply() noexcept
            {
                return false;
            }
        };
        template<>
        struct is_nothrow_invocable_impl_<true>
        {
            template<typename Fn, typename... Args>
            static constexpr bool apply() noexcept
            {
                return noexcept(invoke(std::declval<Fn>(), std::declval<Args>()...));
            }
        };
    } 
    

    template<typename Fn, typename... Args>
    inline constexpr bool is_invocable_v =
        meta::is_trait<invoke_result<Fn, Args...>>::value;

    template<typename Fn, typename... Args>
    inline constexpr bool is_nothrow_invocable_v =
        detail::is_nothrow_invocable_impl_<is_invocable_v<Fn, Args...>>::template apply<
            Fn, Args...>();

    
    template<typename Sig>
    struct [[deprecated("ranges::result_of is deprecated. " "Please use ranges::invoke_result")]] result_of
#line 220 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
    {};

    template<typename Fun, typename... Args>
    struct [[deprecated("ranges::result_of is deprecated. " "Please use ranges::invoke_result")]] result_of<Fun(Args...)>
#line 226 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
      : meta::defer<invoke_result_t, Fun, Args...>
    {};
    

    namespace cpp20
    {
        using ranges::invoke;
        using ranges::invoke_result;
        using ranges::invoke_result_t;
        using ranges::is_invocable_v;
        using ranges::is_nothrow_invocable_v;
    } 

    
} 

__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 245 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"

#line 247 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/invoke.hpp"
#pragma external_header(pop)
#line 20 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"

namespace ranges
{
    
    

    
    

    
    
    template<typename Fun, typename... Args>
    concept invocable =
        std::is_invocable_v<Fun, Args...>;














#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"

    
    
    template<typename Fun, typename... Args>
    concept regular_invocable =
        invocable<Fun, Args...>;
        

    
    
    template<typename Fun, typename... Args>
    concept predicate_requires_ = requires(Fun && fn) { concepts::requires_< convertible_to< decltype(invoke((Fun &&) fn, std::declval<Args>()...)), bool>>; };
#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"
    
    
    template<typename Fun, typename... Args>
    concept predicate =
        regular_invocable<Fun, Args...> &&
        ranges::predicate_requires_<Fun, Args...>;

    
    
    template<typename R, typename T, typename U>
    concept relation =
        predicate<R, T, T> &&
        predicate<R, U, U> &&
        predicate<R, T, U> &&
        predicate<R, U, T>;

    
    
    template<typename R, typename T, typename U>
    concept strict_weak_order =
        relation<R, T, U>;
    

    namespace cpp20
    {
        using ranges::invocable;
        using ranges::predicate;
        using ranges::regular_invocable;
        using ranges::relation;
        using ranges::strict_weak_order;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"

#line 107 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/concepts.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/identity.hpp"

















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 19 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/identity.hpp"

namespace ranges
{
    
    
    struct identity
    {
        template<typename T>
        constexpr T && operator()(T && t) const noexcept
        {
            return (T &&) t;
        }
        using is_transparent = void;
    };

    
    using ident [[deprecated("Replace uses of ranges::ident with ranges::identity")]] =
        identity;
    

    namespace cpp20
    {
        using ranges::identity;
    }
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/identity.hpp"

#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/identity.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"





















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"





















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 23 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"

namespace ranges
{
    
    

    
    
    namespace detail
    {
        struct nil_
        {};

        template<typename T, typename...>
        using always_ = T;


        
        
        
        using std::conditional_t;
        using std::enable_if;
        using std::enable_if_t;

































































#line 112 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"

        template<typename T>
        struct with_difference_type_
        {
            using difference_type = T;
        };

        template<typename T>
        using difference_result_t =
            decltype(std::declval<T const &>() - std::declval<T const &>());

        template<typename, typename = void>
        struct incrementable_traits_2_
        {};

        template<typename T>
        struct incrementable_traits_2_<
            T,

            std::enable_if_t<std::is_integral_v<difference_result_t<T>>>>




#line 137 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"
        {
            using difference_type = std::make_signed_t<difference_result_t<T>>;
        };

        template<typename T, typename = void>
        struct incrementable_traits_1_ : incrementable_traits_2_<T>
        {};

        template<typename T>
        struct incrementable_traits_1_<T *>



          : conditional_t<std::is_object_v<T>, with_difference_type_<std::ptrdiff_t>, nil_>


#line 154 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"
        {};

        template<typename T>
        struct incrementable_traits_1_<T, always_<void, typename T::difference_type>>
        {
            using difference_type = typename T::difference_type;
        };
    } 
    

    template<typename T>
    struct incrementable_traits : detail::incrementable_traits_1_<T>
    {};

    template<typename T>
    struct incrementable_traits<T const> : incrementable_traits<T>
    {};

    
    namespace detail
    {



        template<typename T, bool = std::is_object_v<T>>


#line 182 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"
        struct with_value_type_
        {};
        template<typename T>
        struct with_value_type_<T, true>
        {
            using value_type = T;
        };
        template<typename T>
        struct with_value_type_<T const, true>
        {
            using value_type = T;
        };
        template<typename T>
        struct with_value_type_<T volatile, true>
        {
            using value_type = T;
        };
        template<typename T>
        struct with_value_type_<T const volatile, true>
        {
            using value_type = T;
        };
        template<typename, typename = void>
        struct readable_traits_2_
        {};
        template<typename T>
        struct readable_traits_2_<T, always_<void, typename T::element_type>>
          : with_value_type_<typename T::element_type>
        {};
        template<typename T, typename = void>
        struct readable_traits_1_ : readable_traits_2_<T>
        {};
        template<typename T>
        struct readable_traits_1_<T[]> : with_value_type_<T>
        {};
        template<typename T, std::size_t N>
        struct readable_traits_1_<T[N]> : with_value_type_<T>
        {};
        template<typename T>
        struct readable_traits_1_<T *> : detail::with_value_type_<T>
        {};
        template<typename T>
        struct readable_traits_1_<T, always_<void, typename T::value_type>>
          : with_value_type_<typename T::value_type>
        {};
    } 
    

    
    
    
    
    template<typename T>
    struct indirectly_readable_traits : detail::readable_traits_1_<T>
    {};

    template<typename T>
    struct indirectly_readable_traits<T const> : indirectly_readable_traits<T>
    {};

    
    namespace detail
    {
        template<typename D = std::ptrdiff_t>
        struct std_output_iterator_traits
        {
            using iterator_category = std::output_iterator_tag;
            using difference_type = D;
            using value_type = void;
            using reference = void;
            using pointer = void;
        };

        
        

        template<typename I>
        inline constexpr bool is_std_iterator_traits_specialized_v =
            !std::_Is_from_primary<std::iterator_traits<I>>;








































#line 302 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"
        
        
        
        template<typename T>
        inline constexpr bool is_std_iterator_traits_specialized_v<T *> =
            false;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 313 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"

#line 315 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\std/detail/associated_types.hpp"
#pragma external_header(pop)
#line 23 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"







#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/move.hpp"
























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/move.hpp"

namespace ranges
{
    namespace aux
    {
        
        struct move_fn : move_tag
        {
            template<typename T>
            constexpr meta::_t<std::remove_reference<T>> && operator()(T && t) const 
                noexcept
            {
                return static_cast<meta::_t<std::remove_reference<T>> &&>(t);
            }

            
            
            template<typename T>
            friend constexpr decltype(auto) operator|(T && t, move_fn move) noexcept
            {
                return move(t);
            }
        };

        
        
        inline constexpr move_fn move{};

        
        
        template<typename R>
        using move_t =
            meta::if_c<std::is_reference<R>::value, meta::_t<std::remove_reference<R>> &&,
                       detail::decay_t<R>>;
    } 
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/move.hpp"

#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/move.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/swap.hpp"
























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/swap.hpp"

namespace ranges
{
    template<typename T>
    using is_swappable = concepts::is_swappable<T>;

    template<typename T>
    using is_nothrow_swappable = concepts::is_nothrow_swappable<T>;

    template<typename T, typename U>
    using is_swappable_with = concepts::is_swappable_with<T, U>;

    template<typename T, typename U>
    using is_nothrow_swappable_with = concepts::is_nothrow_swappable_with<T, U>;

    using concepts::exchange;

    
    
    namespace _ { inline constexpr uncvref_t<decltype(concepts::swap)> swap{}; } using namespace _;

    namespace cpp20
    {
        using ranges::swap;
    }
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/swap.hpp"

#line 56 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/swap.hpp"
#pragma external_header(pop)
#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 35 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        template<typename I,

                 typename R = meta::conditional_t<
                     std::is_pointer<uncvref_t<I>>::value &&
                         std::is_array<std::remove_pointer_t<uncvref_t<I>>>::value,
                     std::add_lvalue_reference_t<std::remove_pointer_t<uncvref_t<I>>>,
                     decltype(*std::declval<I &>())>,


#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
                 typename = R &>
        using iter_reference_t_ = R;








#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
        template<typename T>
        using iter_value_t_ = typename indirectly_readable_traits<T>::value_type;
#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
    } 
    

    template<typename R>
    using iter_reference_t = detail::iter_reference_t_<R>;

    template<typename R>
    using iter_value_t = detail::iter_value_t_<uncvref_t<R>>;

    
    namespace _iter_move_
    {


#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"

        template<typename T>
        decltype(iter_move(std::declval<T>())) try_adl_iter_move_(int);

        template<typename T>
        void try_adl_iter_move_(long);

        template<typename T>
        inline constexpr bool is_adl_indirectly_movable_v =
            !std::is_same_v<void, decltype(_iter_move_::try_adl_iter_move_<T>(42))>;

        struct fn
        {
            
            template<typename I,
                     typename = detail::enable_if_t<is_adl_indirectly_movable_v<I &>>>

            constexpr
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
            auto operator() (I &&i) const noexcept(noexcept(iter_move(i))) -> decltype(iter_move(i)) { return (iter_move(i)); }
#line 107 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"

            template<
                typename I,
                typename = detail::enable_if_t<!is_adl_indirectly_movable_v<I &>>,
                typename R = iter_reference_t<I>>

            constexpr
#line 115 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
            auto operator() (I &&i) const noexcept(noexcept(static_cast<aux::move_t<R>>(aux::move(*i)))) -> decltype(static_cast<aux::move_t<R>>(aux::move(*i))) { return (static_cast<aux::move_t<R>>(aux::move(*i))); }
#line 119 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
            
        };
    } 
    

    namespace _ { inline constexpr _iter_move_::fn iter_move{}; } using namespace _;

    
    namespace detail
    {
        template<typename I, typename O>
        auto is_indirectly_movable_(I & (*i)(), O & (*o)(), iter_value_t<I> * v = nullptr)
            -> always_<std::true_type,
                       decltype(iter_value_t<I>(iter_move(i()))),
                       decltype(*v = iter_move(i())),
                       decltype(*o() = (iter_value_t<I> &&) * v),
                       decltype(*o() = iter_move(i()))>;
        template<typename I, typename O>
        auto is_indirectly_movable_(...) -> std::false_type;

        template<typename I, typename O>
        auto is_nothrow_indirectly_movable_(iter_value_t<I> * v) -> meta::bool_<
            noexcept(iter_value_t<I>(iter_move(std::declval<I &>()))) &&
            noexcept(*v = iter_move(std::declval<I &>())) &&
            noexcept(*std::declval<O &>() = (iter_value_t<I> &&) * v) &&
            noexcept(*std::declval<O &>() = iter_move(std::declval<I &>()))>;
        template<typename I, typename O>
        auto is_nothrow_indirectly_movable_(...) -> std::false_type;
    } 
    

    template<typename I, typename O>
    inline constexpr bool is_indirectly_movable_v =
        decltype(detail::is_indirectly_movable_<I, O>(nullptr, nullptr))::value;

    template<typename I, typename O>
    inline constexpr bool is_nothrow_indirectly_movable_v =
        decltype(detail::is_nothrow_indirectly_movable_<I, O>(nullptr))::value;

    template<typename I, typename O>
    struct is_indirectly_movable : meta::bool_<is_indirectly_movable_v<I, O>>
    {};

    template<typename I, typename O>
    struct is_nothrow_indirectly_movable
      : meta::bool_<is_nothrow_indirectly_movable_v<I, O>>
    {};

    
    namespace _iter_swap_
    {
        struct nope
        {};

        
        
        
        
        
        

        
        
        
        

        
        
        

        
        
        template<typename T, typename U>
        nope iter_swap(T, U) = delete;





        template<typename T, typename U>
        decltype(iter_swap(std::declval<T>(), std::declval<U>())) try_adl_iter_swap_(int);

        template<typename T, typename U>
        nope try_adl_iter_swap_(long);

        
        
        
        
        template<typename T, typename U>
        inline constexpr bool is_adl_indirectly_swappable_v =
            !std::is_same_v<nope, decltype(_iter_swap_::try_adl_iter_swap_<T, U>(42))>;

        struct fn
        {
            
            template<typename T, typename U>
            constexpr detail::enable_if_t<is_adl_indirectly_swappable_v<T, U>> operator()(
                T && t, U && u) const noexcept(noexcept(iter_swap((T &&) t, (U &&) u)))
            {
                (void)iter_swap((T &&) t, (U &&) u);
            }

            
            
            template<typename I0, typename I1>
            constexpr detail::enable_if_t<
                !is_adl_indirectly_swappable_v<I0, I1> &&
                is_swappable_with<iter_reference_t<I0>, iter_reference_t<I1>>::value>
            operator()(I0 && a, I1 && b) const noexcept(noexcept(ranges::swap(*a, *b)))
            {
                ranges::swap(*a, *b);
            }

            
            
            
            
            
            template<typename I0, typename I1>
            constexpr detail::enable_if_t<
                !is_adl_indirectly_swappable_v<I0, I1> &&
                !is_swappable_with<iter_reference_t<I0>, iter_reference_t<I1>>::value &&
                is_indirectly_movable_v<I0, I1> && is_indirectly_movable_v<I1, I0>>
            operator()(I0 && a, I1 && b) const
                noexcept(is_nothrow_indirectly_movable_v<I0, I1> &&
                             is_nothrow_indirectly_movable_v<I1, I0>)
            {
                iter_value_t<I0> v0 = iter_move(a);
                *a = iter_move(b);
                *b = detail::move(v0);
            }
        };
    } 
    

    
    namespace _ { inline constexpr _iter_swap_::fn iter_swap{}; } using namespace _;

    
    namespace detail
    {
        template<typename T, typename U>
        auto is_indirectly_swappable_(T & (*t)(), U & (*u)())
            -> detail::always_<std::true_type, decltype(iter_swap(t(), u()))>;
        template<typename T, typename U>
        auto is_indirectly_swappable_(...) -> std::false_type;

        template<typename T, typename U>
        auto is_nothrow_indirectly_swappable_(int)
            -> meta::bool_<noexcept(iter_swap(std::declval<T &>(), std::declval<U &>()))>;
        template<typename T, typename U>
        auto is_nothrow_indirectly_swappable_(long) -> std::false_type;
    } 
    

    template<typename T, typename U>
    inline constexpr bool is_indirectly_swappable_v =
        decltype(detail::is_indirectly_swappable_<T, U>(nullptr, nullptr))::value;

    template<typename T, typename U>
    inline constexpr bool is_nothrow_indirectly_swappable_v =
        decltype(detail::is_nothrow_indirectly_swappable_<T, U>(0))::value;

    template<typename T, typename U>
    struct is_indirectly_swappable : meta::bool_<is_indirectly_swappable_v<T, U>>
    {};

    template<typename T, typename U>
    struct is_nothrow_indirectly_swappable
      : meta::bool_<is_nothrow_indirectly_swappable_v<T, U>>
    {};

    namespace cpp20
    {
        using ranges::iter_move;
        using ranges::iter_reference_t;
        using ranges::iter_swap;
        using ranges::iter_value_t;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 303 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"

#line 305 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/access.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_type.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_type.hpp"








namespace ranges
{
    template<typename... Ts>
    using common_type = concepts::common_type<Ts...>;

    template<typename... Ts>
    using common_type_t = concepts::common_type_t<Ts...>;

    template<typename... Ts>
    using common_reference = concepts::common_reference<Ts...>;

    template<typename... Ts>
    using common_reference_t = concepts::common_reference_t<Ts...>;

    
    template<typename F, typename S>
    struct common_pair;

    template<typename... Ts>
    struct common_tuple;
    
} 



namespace concepts
{
    
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<std::pair<F1, S1>, ::ranges::common_pair<F2, S2>>;

    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<::ranges::common_pair<F1, S1>, std::pair<F2, S2>>;

    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<::ranges::common_pair<F1, S1>, ::ranges::common_pair<F2, S2>>;

    
    template<typename... Ts, typename... Us>
    struct common_type<::ranges::common_tuple<Ts...>, std::tuple<Us...>>;

    template<typename... Ts, typename... Us>
    struct common_type<std::tuple<Ts...>, ::ranges::common_tuple<Us...>>;

    template<typename... Ts, typename... Us>
    struct common_type<::ranges::common_tuple<Ts...>, ::ranges::common_tuple<Us...>>;

    
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_pair<F1, S1>, std::pair<F2, S2>, Qual1, Qual2>;

    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<std::pair<F1, S1>, ::ranges::common_pair<F2, S2>, Qual1, Qual2>;

    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_pair<F1, S1>, ::ranges::common_pair<F2, S2>, Qual1, Qual2>;

    
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_tuple<Ts...>, std::tuple<Us...>, Qual1, Qual2>;

    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<std::tuple<Ts...>, ::ranges::common_tuple<Us...>, Qual1, Qual2>;

    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_tuple<Ts...>, ::ranges::common_tuple<Us...>, Qual1, Qual2>;
} 


__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))
namespace std {


    template<typename...>
    struct common_type;

    
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<std::pair<F1, S1>, ::ranges::common_pair<F2, S2>>;

    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<::ranges::common_pair<F1, S1>, std::pair<F2, S2>>;

    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<::ranges::common_pair<F1, S1>, ::ranges::common_pair<F2, S2>>;

    
    template<typename... Ts, typename... Us>
    struct common_type<::ranges::common_tuple<Ts...>, std::tuple<Us...>>;

    template<typename... Ts, typename... Us>
    struct common_type<std::tuple<Ts...>, ::ranges::common_tuple<Us...>>;

    template<typename... Ts, typename... Us>
    struct common_type<::ranges::common_tuple<Ts...>, ::ranges::common_tuple<Us...>>;

    template<typename, typename, template<typename> class, template<typename> class>
    struct basic_common_reference;

    
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_pair<F1, S1>, std::pair<F2, S2>, Qual1, Qual2>;

    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<std::pair<F1, S1>, ::ranges::common_pair<F2, S2>, Qual1, Qual2>;

    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_pair<F1, S1>, ::ranges::common_pair<F2, S2>, Qual1, Qual2>;

    
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_tuple<Ts...>, std::tuple<Us...>, Qual1, Qual2>;

    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<std::tuple<Ts...>, ::ranges::common_tuple<Us...>, Qual1, Qual2>;

    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_tuple<Ts...>, ::ranges::common_tuple<Us...>, Qual1, Qual2>;


}
__pragma(warning(pop))
#line 171 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_type.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 174 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_type.hpp"

#line 176 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_type.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

namespace ranges
{
    
    

    
    using input_iterator_tag [[deprecated("Please switch to the standard iterator tags")]] = std::input_iterator_tag;
#line 39 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
    using forward_iterator_tag [[deprecated("Please switch to the standard iterator tags")]] = std::forward_iterator_tag;
#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
    using bidirectional_iterator_tag [[deprecated("Please switch to the standard iterator tags")]] = std::bidirectional_iterator_tag;
#line 43 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
    using random_access_iterator_tag [[deprecated("Please switch to the standard iterator tags")]] = std::random_access_iterator_tag;
#line 45 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
    

    struct contiguous_iterator_tag : std::random_access_iterator_tag
    {};

    
    namespace detail
    {
        template<typename I, typename = iter_reference_t<I>,
                 typename R = decltype(iter_move(std::declval<I &>())), typename = R &>
        using iter_rvalue_reference_t = R;

        template<typename I>
        inline constexpr bool has_nothrow_iter_move_v =
            noexcept(iter_rvalue_reference_t<I>(ranges::iter_move(std::declval<I &>())));
    } 
    

    template<typename I>
    using iter_rvalue_reference_t = detail::iter_rvalue_reference_t<I>;

    template<typename I>
    using iter_common_reference_t =
        common_reference_t<iter_reference_t<I>, iter_value_t<I> &>;







#line 78 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
    template<typename T>
    using iter_difference_t =
        typename incrementable_traits<uncvref_t<T>>::difference_type;
#line 82 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

    
    
    

    
    
    

    
    
    

    
    namespace detail
    {
        template<typename I>
        using iter_size_t =
            meta::_t<meta::conditional_t<std::is_integral<iter_difference_t<I>>::value,
                               std::make_unsigned<iter_difference_t<I>>,
                               meta::id<iter_difference_t<I>>>>;

        template<typename I>
        using iter_arrow_t = decltype(std::declval<I &>().operator->());

        template<typename I>
        using iter_pointer_t =
            meta::_t<meta::conditional_t<
                        meta::is_trait<meta::defer<iter_arrow_t, I>>::value,
                        meta::defer<iter_arrow_t, I>,
                        std::add_pointer<iter_reference_t<I>>>>;

        template<typename T>
        struct difference_type_ : meta::defer<iter_difference_t, T>
        {};

        template<typename T>
        struct value_type_ : meta::defer<iter_value_t, T>
        {};

        template<typename T>
        struct size_type_ : meta::defer<iter_size_t, T>
        {};
    } 

    template<typename T>
    using difference_type_t [[deprecated("ranges::difference_type_t is deprecated. Please use " "ranges::iter_difference_t instead.")]] = iter_difference_t<T>;
#line 131 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

    template<typename T>
    using value_type_t [[deprecated("ranges::value_type_t is deprecated. Please use " "ranges::iter_value_t instead.")]] = iter_value_t<T>;
#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

    template<typename R>
    using reference_t [[deprecated("ranges::reference_t is deprecated. Use ranges::iter_reference_t " "instead.")]] = iter_reference_t<R>;
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

    template<typename I>
    using rvalue_reference_t [[deprecated("rvalue_reference_t is deprecated; " "use iter_rvalue_reference_t instead")]] = iter_rvalue_reference_t<I>;
#line 146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

    template<typename T>
    struct [[deprecated("ranges::size_type is deprecated. Iterators do not have an associated " "size_type.")]] size_type : detail::size_type_<T>
#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
    {};

    template<typename I>
    using size_type_t [[deprecated("size_type_t is deprecated.")]] =
        detail::iter_size_t<I>;
    

    namespace cpp20
    {
        using ranges::iter_common_reference_t;
        using ranges::iter_difference_t;
        using ranges::iter_reference_t;
        using ranges::iter_rvalue_reference_t;
        using ranges::iter_value_t;

        
        using ranges::disable_sized_sentinel;
        template<typename T>
        using incrementable_traits = ranges::incrementable_traits<T>;
        template<typename T>
        using indirectly_readable_traits = ranges::indirectly_readable_traits<T>;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 177 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"

#line 179 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/traits.hpp"
#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"





#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 38 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        template<typename I>
        using iter_traits_t = meta::conditional_t<is_std_iterator_traits_specialized_v<I>,
                                        std::iterator_traits<I>, I>;






#line 57 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"





#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"





#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

         template<typename I > requires same_as<I, class I::_Array_iterator>
#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
         template<typename I > requires same_as<I, class I::_Array_const_iterator>
#line 76 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
         template<typename I > requires same_as<I, class I::_Vector_iterator>
#line 80 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
         template<typename I > requires same_as<I, class I::_Vector_const_iterator>
#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
         template<typename I > requires same_as<I, class I::_String_iterator>
#line 88 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
         template<typename I > requires same_as<I, class I::_String_const_iterator>
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
         template<typename I > requires same_as<I, class I::_String_view_iterator>
#line 96 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(I, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
#line 99 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
         template<typename I, typename T > requires same_as<I, T *>
#line 101 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        auto iter_concept_(T *, priority_tag<3>)
            -> ranges::contiguous_iterator_tag;
        template<typename I>
        auto iter_concept_(I, priority_tag<2>) ->
            typename iter_traits_t<I>::iterator_concept;
        template<typename I>
        auto iter_concept_(I, priority_tag<1>) ->
            typename iter_traits_t<I>::iterator_category;
        template<typename I>
        auto iter_concept_(I, priority_tag<0>)
            -> enable_if_t<!is_std_iterator_traits_specialized_v<I>,
                           std::random_access_iterator_tag>;

        template<typename I>
        using iter_concept_t =
            decltype(iter_concept_<I>(std::declval<I>(), priority_tag<3>{}));

        using ::concepts::detail::weakly_equality_comparable_with_;

        template<typename I>
        using readable_types_t =
            meta::list<iter_value_t<I>, iter_reference_t<I>, iter_rvalue_reference_t<I>>;
    } 
      

    
    
    
     template<typename I > concept readable_concept_ = same_as<iter_reference_t<I const>, iter_reference_t<I>> && same_as<iter_rvalue_reference_t<I const>, iter_rvalue_reference_t<I>> && common_reference_with<iter_reference_t<I> &&, iter_value_t<I> &> && common_reference_with<iter_reference_t<I> &&, iter_rvalue_reference_t<I> &&> && common_reference_with<iter_rvalue_reference_t<I> &&, iter_value_t<I> const &>;
#line 143 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I>
    concept indirectly_readable = 
        ranges::readable_concept_<uncvref_t<I>>;

    template<typename I>
    [[deprecated("Please use ranges::indirectly_readable instead")]]
    inline constexpr bool readable = 
        indirectly_readable<I>;

    
    
    template<typename O, typename T>
    concept writable_requires_ = requires(O && o, T && t) { *o = (T &&) t, *(O &&) o = (T &&) t, const_cast<iter_reference_t<O> const &&>(*o) = (T &&) t, const_cast<iter_reference_t<O> const &&>(*(O &&) o) = (T &&) t; };
#line 166 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
    template<typename O, typename T>
    concept indirectly_writable = 
        ranges::writable_requires_<O, T>;

    template<typename O, typename T>
    [[deprecated("Please use ranges::indirectly_writable instead")]]
    inline constexpr bool writable = 
        indirectly_writable<O, T>;
    

    
    namespace detail
    {

        template<typename D>
        inline constexpr bool _is_integer_like_ = std::is_integral<D>::value;



#line 188 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

        
        









#line 201 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

        
        
        
        template<typename D>
        concept integer_like_ = _is_integer_like_<D>;
            


        template<typename D, bool Signed = (D(-1) < D(0))>
        constexpr bool _is_signed_(D *)
        {
            return Signed;
        }
        constexpr bool _is_signed_(void *)
        {
            return false;
        }

        
        
        template<typename D>
        concept signed_integer_like_ =
            integer_like_<D> && detail::_is_signed_((D*) nullptr);
















#line 242 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        
    } 
      

    
    
    
    template<typename I>
    concept weakly_incrementable_requires_ = requires(I i) { ++i, i++, concepts::requires_<same_as<I&, decltype(++i)>>; };
#line 257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
     template<typename I > concept weakly_incrementable_concept_ = concepts::type<iter_difference_t<I>> && detail::signed_integer_like_<iter_difference_t<I>>;
#line 264 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I>
    concept weakly_incrementable =
        copyable<I> &&
        ranges::weakly_incrementable_requires_<I> &&
        ranges::weakly_incrementable_concept_<I>;

    
    
    template<typename I>
    concept incrementable_requires_ = requires(I i) { concepts::requires_<same_as<I, decltype(i++)>>; };
#line 281 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
    template<typename I>
    concept incrementable =
        regular<I> &&
        weakly_incrementable<I> &&
        ranges::incrementable_requires_<I>;

    
    
     template<typename I > concept input_or_output_iterator_concept_ = detail::dereferenceable_<I&>;
#line 295 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I>
    concept input_or_output_iterator =
        weakly_incrementable<I> &&
        ranges::input_or_output_iterator_concept_<I>;

    
    
    template<typename S, typename I>
    concept sentinel_for =
        semiregular<S> &&
        input_or_output_iterator<I> &&
        detail::weakly_equality_comparable_with_<S, I>;

    
    
    template<typename S, typename I>
    concept sized_sentinel_for_requires_ = requires(S const & s, I const & i) { s - i, i - s, concepts::requires_<same_as<iter_difference_t<I>, decltype(s - i)>>, concepts::requires_<same_as<iter_difference_t<I>, decltype(i - s)>>; };
#line 322 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
     template<typename S, typename I > concept sized_sentinel_for_concept_ = (!disable_sized_sentinel<std::remove_cv_t<S>, std::remove_cv_t<I>>) && sentinel_for<S, I>;
#line 328 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename S, typename I>
    concept sized_sentinel_for =
        sized_sentinel_for_concept_<S, I> &&
        ranges::sized_sentinel_for_requires_<S, I>;

    
    
    template<typename Out, typename T>
    concept output_iterator_requires_ = requires(Out o, T && t) { *o++ = (T &&) t; };
#line 344 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
    template<typename Out, typename T>
    concept output_iterator =
        input_or_output_iterator<Out> &&
        indirectly_writable<Out, T> &&
        ranges::output_iterator_requires_<Out, T>;

    
    
     template<typename I, typename Tag > concept with_category_concept_ = derived_from<detail::iter_concept_t<I>, Tag>;
#line 358 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I>
    concept input_iterator =
        input_or_output_iterator<I> &&
        indirectly_readable<I> &&
        ranges::with_category_concept_<I, std::input_iterator_tag>;

    
    
    template<typename I>
    concept forward_iterator =
        input_iterator<I> &&
        incrementable<I> &&
        sentinel_for<I, I> &&
        ranges::with_category_concept_<I, std::forward_iterator_tag>;

    
    
    template<typename I>
    concept bidirectional_iterator_requires_ = requires(I i) { --i, i--, concepts::requires_<same_as<I&, decltype(--i)>>, concepts::requires_<same_as<I, decltype(i--)>>; };
#line 387 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
    template<typename I>
    concept bidirectional_iterator =
        forward_iterator<I> &&
        ranges::bidirectional_iterator_requires_<I> &&
        ranges::with_category_concept_<I, std::bidirectional_iterator_tag>;

    
    
    template<typename I>
    concept random_access_iterator_requires_ = requires(I i, iter_difference_t<I> n) { i + n, n + i, i - n, i += n, i -= n, concepts::requires_<same_as<decltype(i + n), I>>, concepts::requires_<same_as<decltype(n + i), I>>, concepts::requires_<same_as<decltype(i - n), I>>, concepts::requires_<same_as<decltype(i += n), I&>>, concepts::requires_<same_as<decltype(i -= n), I&>>, concepts::requires_<same_as<decltype(i[n]), iter_reference_t<I>>>; };
#line 413 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
    template<typename I>
    concept random_access_iterator =
        bidirectional_iterator<I> &&
        totally_ordered<I> &&
        sized_sentinel_for<I, I> &&
        ranges::random_access_iterator_requires_<I> &&
        ranges::with_category_concept_<I, std::random_access_iterator_tag>;

    
    
     template<typename I > concept contiguous_iterator_concept_ = std::is_lvalue_reference<iter_reference_t<I>>::value && same_as<iter_value_t<I>, uncvref_t<iter_reference_t<I>>> && derived_from<detail::iter_concept_t<I>, ranges::contiguous_iterator_tag>;
#line 431 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I>
    concept contiguous_iterator =
        random_access_iterator<I> &&
        ranges::contiguous_iterator_concept_<I>;
    

    
    
    template<typename Rng>
    using iterator_tag_of =                              
        std::enable_if_t<                                
            input_iterator<Rng>,                         
            meta::conditional_t<                           
                contiguous_iterator<Rng>,                
                ranges::contiguous_iterator_tag,         
                meta::conditional_t<                       
                    random_access_iterator<Rng>,         
                    std::random_access_iterator_tag,     
                    meta::conditional_t<                   
                        bidirectional_iterator<Rng>,     
                        std::bidirectional_iterator_tag, 
                        meta::conditional_t<               
                            forward_iterator<Rng>,       
                            std::forward_iterator_tag,   
                            std::input_iterator_tag>>>>>;

    
    namespace detail
    {
        template<typename, bool>
        struct iterator_category_
        {};

        template<typename I>
        struct iterator_category_<I, true>
        {
            using type = iterator_tag_of<I>;
        };

        template<typename T, typename U = meta::_t<std::remove_const<T>>>
        using iterator_category = iterator_category_<U, (bool)input_iterator<U>>;
    } 
    

    
    
    
    
    
    template<typename I>
    concept single_pass_iterator_ =
        input_or_output_iterator<I> && !forward_iterator<I>;
    
    

    
    
    template<typename Fun, typename... Is>
    using indirect_result_t =
        detail::enable_if_t<(bool)and_v<(bool)indirectly_readable<Is>...>,
                            invoke_result_t<Fun, iter_reference_t<Is>...>>;

    
    namespace detail
    {
        
        
        
         template<typename T1, typename T2, typename T3, typename T4 > concept common_reference_with_4_impl_concept_ = concepts::type<common_reference_t<T1, T2, T3, T4>> && convertible_to<T1, common_reference_t<T1, T2, T3, T4>> && convertible_to<T2, common_reference_t<T1, T2, T3, T4>> && convertible_to<T3, common_reference_t<T1, T2, T3, T4>> && convertible_to<T4, common_reference_t<T1, T2, T3, T4>>;
#line 510 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

        
        
        template<typename T1, typename T2, typename T3, typename T4>
        concept common_reference_with_4_ =
            detail::common_reference_with_4_impl_concept_<T1, T2, T3, T4>;
        
        

        
        
         template<typename F, typename I > concept indirectly_unary_invocable_impl_concept_ = invocable<F &, iter_value_t<I> &> && invocable<F &, iter_reference_t<I>> && invocable<F &, iter_common_reference_t<I>> && common_reference_with< invoke_result_t<F &, iter_value_t<I> &>, invoke_result_t<F &, iter_reference_t<I>>>;
#line 530 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

        
        
        template<typename F, typename I>
        concept indirectly_unary_invocable_ =
            indirectly_readable<I> &&
            detail::indirectly_unary_invocable_impl_concept_<F, I>;
        
    } 
      

    
    
    
    template<typename F, typename I>
    concept indirectly_unary_invocable =
        detail::indirectly_unary_invocable_<F, I> &&
        copy_constructible<F>;

    
    
     template<typename F, typename I > concept indirectly_regular_unary_invocable_concept_ = regular_invocable<F &, iter_value_t<I> &> && regular_invocable<F &, iter_reference_t<I>> && regular_invocable<F &, iter_common_reference_t<I>> && common_reference_with< invoke_result_t<F &, iter_value_t<I> &>, invoke_result_t<F &, iter_reference_t<I>>>;
#line 560 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I>
    concept indirectly_regular_unary_invocable =
        indirectly_readable<I> &&
        copy_constructible<F> &&
        ranges::indirectly_regular_unary_invocable_concept_<F, I>;

    
    
    
    
     template<typename F, typename I1, typename I2 > concept indirectly_binary_invocable_impl_concept_ = invocable<F &, iter_value_t<I1> &, iter_value_t<I2> &> && invocable<F &, iter_value_t<I1> &, iter_reference_t<I2>> && invocable<F &, iter_reference_t<I1>, iter_value_t<I2> &> && invocable<F &, iter_reference_t<I1>, iter_reference_t<I2>> && invocable<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>> && detail::common_reference_with_4_< invoke_result_t<F &, iter_value_t<I1> &, iter_value_t<I2> &>, invoke_result_t<F &, iter_value_t<I1> &, iter_reference_t<I2>>, invoke_result_t<F &, iter_reference_t<I1>, iter_value_t<I2> &>, invoke_result_t<F &, iter_reference_t<I1>, iter_reference_t<I2>>>;
#line 586 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I1, typename I2>
    concept indirectly_binary_invocable_ =
        indirectly_readable<I1> && indirectly_readable<I2> &&
        copy_constructible<F> &&
        ranges::indirectly_binary_invocable_impl_concept_<F, I1, I2>;

    
    
     template<typename F, typename I1, typename I2 > concept indirectly_regular_binary_invocable_impl_concept_ = regular_invocable<F &, iter_value_t<I1> &, iter_value_t<I2> &> && regular_invocable<F &, iter_value_t<I1> &, iter_reference_t<I2>> && regular_invocable<F &, iter_reference_t<I1>, iter_value_t<I2> &> && regular_invocable<F &, iter_reference_t<I1>, iter_reference_t<I2>> && regular_invocable<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>> && detail::common_reference_with_4_< invoke_result_t<F &, iter_value_t<I1> &, iter_value_t<I2> &>, invoke_result_t<F &, iter_value_t<I1> &, iter_reference_t<I2>>, invoke_result_t<F &, iter_reference_t<I1>, iter_value_t<I2> &>, invoke_result_t<F &, iter_reference_t<I1>, iter_reference_t<I2>>>;
#line 610 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I1, typename I2>
    concept indirectly_regular_binary_invocable_ =
        indirectly_readable<I1> && indirectly_readable<I2> &&
        copy_constructible<F> &&
        ranges::indirectly_regular_binary_invocable_impl_concept_<F, I1, I2>;
    

    
    
     template<typename F, typename I > concept indirect_unary_predicate_concept_ = predicate<F &, iter_value_t<I> &> && predicate<F &, iter_reference_t<I>> && predicate<F &, iter_common_reference_t<I>>;
#line 628 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I>
    concept indirect_unary_predicate =
        indirectly_readable<I> &&
        copy_constructible<F> &&
        ranges::indirect_unary_predicate_concept_<F, I>;

    
    
     template<typename F, typename I1, typename I2 > concept indirect_binary_predicate_impl_concept_ = predicate<F &, iter_value_t<I1> &, iter_value_t<I2> &> && predicate<F &, iter_value_t<I1> &, iter_reference_t<I2>> && predicate<F &, iter_reference_t<I1>, iter_value_t<I2> &> && predicate<F &, iter_reference_t<I1>, iter_reference_t<I2>> && predicate<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
#line 647 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I1, typename I2>
    concept indirect_binary_predicate_ =
        indirectly_readable<I1> && indirectly_readable<I2> &&
        copy_constructible<F> &&
        ranges::indirect_binary_predicate_impl_concept_<F, I1, I2>;

    
    
     template<typename F, typename I1, typename I2 > concept indirect_relation_concept_ = relation<F &, iter_value_t<I1> &, iter_value_t<I2> &> && relation<F &, iter_value_t<I1> &, iter_reference_t<I2>> && relation<F &, iter_reference_t<I1>, iter_value_t<I2> &> && relation<F &, iter_reference_t<I1>, iter_reference_t<I2>> && relation<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
#line 666 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I1, typename I2 = I1>
    concept indirect_relation =
        indirectly_readable<I1> && indirectly_readable<I2> &&
        copy_constructible<F> &&
        ranges::indirect_relation_concept_<F, I1, I2>;

    
    
     template<typename F, typename I1, typename I2 > concept indirect_strict_weak_order_concept_ = strict_weak_order<F &, iter_value_t<I1> &, iter_value_t<I2> &> && strict_weak_order<F &, iter_value_t<I1> &, iter_reference_t<I2>> && strict_weak_order<F &, iter_reference_t<I1>, iter_value_t<I2> &> && strict_weak_order<F &, iter_reference_t<I1>, iter_reference_t<I2>> && strict_weak_order<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
#line 685 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename F, typename I1, typename I2 = I1>
    concept indirect_strict_weak_order =
        indirectly_readable<I1> && indirectly_readable<I2> &&
        copy_constructible<F> &&
        ranges::indirect_strict_weak_order_concept_<F, I1, I2>;
    

    
    
    
    namespace detail
    {
        __pragma(warning(push))
        
        template<typename I, typename Proj>
        struct projected_
        {
            struct type
            {
                using reference = indirect_result_t<Proj &, I>;
                using value_type = uncvref_t<reference>;
                reference operator*() const;
            };
        };
        __pragma(warning(pop))

        template<typename Proj>
        struct select_projected_
        {
            template<typename I>
            using apply =
                meta::_t<
                    detail::enable_if_t<
                        (bool)indirectly_regular_unary_invocable<Proj, I>,
                        detail::projected_<I, Proj>>>;
        };

        template<>
        struct select_projected_<identity>
        {
            template<typename I>
            using apply = detail::enable_if_t<(bool)indirectly_readable<I>, I>;
        };
    } 
    

    template<typename I, typename Proj>
    using projected = typename detail::select_projected_<Proj>::template apply<I>;

    template<typename I, typename Proj>
    struct incrementable_traits<detail::projected_<I, Proj>> : incrementable_traits<I>
    {};

    
    
    
     template<typename I, typename O > concept indirectly_movable_concept_ = indirectly_writable<O, iter_rvalue_reference_t<I>>;
#line 748 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I, typename O>
    concept indirectly_movable =
        indirectly_readable<I> && ranges::indirectly_movable_concept_<I, O>;

    
    
     template<typename I, typename O > concept indirectly_movable_storable_concept_ = indirectly_writable<O, iter_value_t<I>> && movable<iter_value_t<I>> && constructible_from<iter_value_t<I>, iter_rvalue_reference_t<I>> && assignable_from<iter_value_t<I> &, iter_rvalue_reference_t<I>>;
#line 764 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I, typename O>
    concept indirectly_movable_storable =
        indirectly_movable<I, O> &&
        ranges::indirectly_movable_storable_concept_<I, O>;

    
    
     template<typename I, typename O > concept indirectly_copyable_concept_ = indirectly_writable<O, iter_reference_t<I>>;
#line 778 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I, typename O>
    concept indirectly_copyable =
        indirectly_readable<I> && ranges::indirectly_copyable_concept_<I, O>;

    
    
     template<typename I, typename O > concept indirectly_copyable_storable_concept_ = indirectly_writable<O, iter_value_t<I> const &> && copyable<iter_value_t<I>> && constructible_from<iter_value_t<I>, iter_reference_t<I>> && assignable_from<iter_value_t<I> &, iter_reference_t<I>>;
#line 794 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I, typename O>
    concept indirectly_copyable_storable =
        indirectly_copyable<I, O> &&
        ranges::indirectly_copyable_storable_concept_<I, O>;

    
    
    template<typename I1, typename I2>
    concept indirectly_swappable_requires_ = requires(I1 const i1, I2 const i2) { ranges::iter_swap(i1, i2), ranges::iter_swap(i1, i1), ranges::iter_swap(i2, i2), ranges::iter_swap(i2, i1); };
#line 813 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
    
    
    template<typename I1, typename I2 = I1>
    concept indirectly_swappable =
        indirectly_readable<I1> && 
        indirectly_readable<I2> && 
        ranges::indirectly_swappable_requires_<I1, I2>;

    
    
     template<typename C, typename I1, typename P1, typename I2, typename P2 > concept projected_indirect_relation_concept_ = indirect_relation<C, projected<I1, P1>, projected<I2, P2>>;
#line 827 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    
    
    template<typename I1, typename I2, typename C, typename P1 = identity,
        typename P2 = identity>
    concept indirectly_comparable =
        ranges::projected_indirect_relation_concept_<C, I1, P1, I2, P2>;

    
    
    
    
    template<typename I>
    concept permutable =
        forward_iterator<I> &&
        indirectly_swappable<I, I> &&
        indirectly_movable_storable<I, I>;

    
    
     template<typename C, typename I1, typename P1, typename I2, typename P2 > concept projected_indirect_strict_weak_order_concept_ = indirect_strict_weak_order<C, projected<I1, P1>, projected<I2, P2>>;
#line 851 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    template<typename I1, typename I2, typename Out, typename C = less,
        typename P1 = identity, typename P2 = identity>
    concept mergeable =
        input_iterator<I1> &&
        input_iterator<I2> &&
        weakly_incrementable<Out> &&
        indirectly_copyable<I1, Out> &&
        indirectly_copyable<I2, Out> &&
        ranges::projected_indirect_strict_weak_order_concept_<C, I1, P1, I2, P2>;

    
    
    template<typename I, typename C = less, typename P = identity>
    concept sortable =
        permutable<I> &&
        ranges::projected_indirect_strict_weak_order_concept_<C, I, P, I, P>;
    

    struct sentinel_tag
    {};
    struct sized_sentinel_tag : sentinel_tag
    {};

    template<typename S, typename I>
    using sentinel_tag_of =               
        std::enable_if_t<                 
            sentinel_for<S, I>,           
            meta::conditional_t<            
                sized_sentinel_for<S, I>, 
                sized_sentinel_tag,       
                sentinel_tag>>;

    
    
    template<typename I>
    using iterator_category [[deprecated("iterator_category is deprecated. Use the iterator concepts instead")]] =
#line 889 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        detail::iterator_category<I>;

    template<typename I>
    using iterator_category_t [[deprecated("iterator_category_t is deprecated. Use the iterator concepts instead")]] =
#line 894 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
        meta::_t<detail::iterator_category<I>>;

    template<typename Fun, typename... Is>
    using indirect_invoke_result_t [[deprecated("Please switch to indirect_result_t")]] = indirect_result_t<Fun, Is...>;
#line 899 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

    template<typename Fun, typename... Is>
    struct [[deprecated("Please switch to indirect_result_t")]] indirect_invoke_result
      : meta::defer<indirect_result_t, Fun, Is...>
    {};

    template<typename Sig>
    struct indirect_result_of
    {};

    template<typename Fun, typename... Is>
    struct [[deprecated("Please switch to indirect_result_t")]]
        indirect_result_of<Fun(Is...)> : meta::defer<indirect_result_t, Fun, Is...>
    {};

    template<typename Sig>
    using indirect_result_of_t [[deprecated("Please switch to indirect_result_t")]] =
        meta::_t<indirect_result_of<Sig>>;
    

    namespace cpp20
    {
        using ranges::bidirectional_iterator;
        using ranges::contiguous_iterator;
        using ranges::forward_iterator;
        using ranges::incrementable;
        using ranges::indirect_relation;
        using ranges::indirect_result_t;
        using ranges::indirect_strict_weak_order;
        using ranges::indirect_unary_predicate;
        using ranges::indirectly_comparable;
        using ranges::indirectly_copyable;
        using ranges::indirectly_copyable_storable;
        using ranges::indirectly_movable;
        using ranges::indirectly_movable_storable;
        using ranges::indirectly_readable;
        using ranges::indirectly_regular_unary_invocable;
        using ranges::indirectly_swappable;
        using ranges::indirectly_unary_invocable;
        using ranges::indirectly_writable;
        using ranges::input_iterator;
        using ranges::input_or_output_iterator;
        using ranges::mergeable;
        using ranges::output_iterator;
        using ranges::permutable;
        using ranges::projected;
        using ranges::random_access_iterator;
        using ranges::sentinel_for;
        using ranges::sized_sentinel_for;
        using ranges::sortable;
        using ranges::weakly_incrementable;
    } 
    
} 

































#line 987 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 989 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"

#line 991 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/concepts.hpp"
#pragma external_header(pop)
#line 40 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"



























#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"


#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"




#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"



















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"




























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"

namespace ranges
{
    
    
    struct range_access
    {
        
    private:
        template<typename T>
        static std::false_type single_pass_2_(long);
        template<typename T>
        static typename T::single_pass single_pass_2_(int);

        template<typename T>
        struct single_pass_
        {
            using type = decltype(range_access::single_pass_2_<T>(42));
        };

        template<typename T>
        static std::false_type contiguous_2_(long);
        template<typename T>
        static typename T::contiguous contiguous_2_(int);

        template<typename T>
        struct contiguous_
        {
            using type = decltype(range_access::contiguous_2_<T>(42));
        };

        template<typename T>
        static basic_mixin<T> mixin_base_2_(long);
        template<typename T>
        static typename T::mixin mixin_base_2_(int);

        template<typename Cur>
        struct mixin_base_
        {
            using type = decltype(range_access::mixin_base_2_<Cur>(42));
        };


    public:
        template<typename Cur>
        using single_pass_t = meta::_t<single_pass_<Cur>>;

        template<typename Cur>
        using contiguous_t = meta::_t<contiguous_<Cur>>;

        template<typename Cur>
        using mixin_base_t = meta::_t<mixin_base_<Cur>>;

        
        template<typename Rng>
        static constexpr auto begin_cursor (Rng &rng) noexcept(noexcept(rng.begin_cursor())) -> decltype(rng.begin_cursor()) { return (rng.begin_cursor()); }
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Rng>
        static constexpr auto end_cursor (Rng &rng) noexcept(noexcept(rng.end_cursor())) -> decltype(rng.end_cursor()) { return (rng.end_cursor()); }
#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"

        template<typename Rng>
        static constexpr auto begin_adaptor (Rng &rng) noexcept(noexcept(rng.begin_adaptor())) -> decltype(rng.begin_adaptor()) { return (rng.begin_adaptor()); }
#line 100 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Rng>
        static constexpr auto end_adaptor (Rng &rng) noexcept(noexcept(rng.end_adaptor())) -> decltype(rng.end_adaptor()) { return (rng.end_adaptor()); }
#line 105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"

        template<typename Cur>
        static constexpr auto read (Cur const &pos) noexcept(noexcept(pos.read())) -> decltype(pos.read()) { return (pos.read()); }
#line 111 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur>
        static constexpr auto arrow (Cur const &pos) noexcept(noexcept(pos.arrow())) -> decltype(pos.arrow()) { return (pos.arrow()); }
#line 116 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur>
        static constexpr auto move (Cur const &pos) noexcept(noexcept(pos.move())) -> decltype(pos.move()) { return (pos.move()); }
#line 121 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur, typename T>
        static constexpr auto write (Cur &pos, T &&t) noexcept(noexcept(pos.write((T &&) t))) -> decltype(pos.write((T &&) t)) { return (pos.write((T &&) t)); }
#line 126 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur>
        static constexpr auto next (Cur & pos) noexcept(noexcept(pos.next())) -> decltype(pos.next()) { return (pos.next()); }
#line 131 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur, typename O>
        static constexpr auto equal (Cur const &pos, O const &other) noexcept(noexcept(pos.equal(other))) -> decltype(pos.equal(other)) { return (pos.equal(other)); }
#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur>
        static constexpr auto prev (Cur & pos) noexcept(noexcept(pos.prev())) -> decltype(pos.prev()) { return (pos.prev()); }
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur, typename D>
        static constexpr auto advance (Cur & pos, D n) noexcept(noexcept(pos.advance(n))) -> decltype(pos.advance(n)) { return (pos.advance(n)); }
#line 146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        template<typename Cur, typename O>
        static constexpr auto distance_to (Cur const &pos, O const &other) noexcept(noexcept(pos.distance_to(other))) -> decltype(pos.distance_to(other)) { return (pos.distance_to(other)); }
#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"

    private:
        template<typename Cur>
        using sized_cursor_difference_t = decltype(
            range_access::distance_to(std::declval<Cur>(), std::declval<Cur>()));
        

        template<typename T>
        static std::ptrdiff_t cursor_difference_2_(detail::ignore_t);
        template<typename T>
        static sized_cursor_difference_t<T> cursor_difference_2_(long);
        template<typename T>
        static typename T::difference_type cursor_difference_2_(int);

        template<typename T>
        using cursor_reference_t = decltype(std::declval<T const &>().read());

        template<typename T>
        static meta::id<uncvref_t<cursor_reference_t<T>>> cursor_value_2_(long);
        template<typename T>
        static meta::id<typename T::value_type> cursor_value_2_(int);












    public:







        template<typename Cur>
        using cursor_difference_t = decltype(range_access::cursor_difference_2_<Cur>(42));

        template<typename Cur>
        using cursor_value_t = meta::_t<decltype(range_access::cursor_value_2_<Cur>(42))>;
#line 198 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"

        template<typename Cur>
        static constexpr Cur & pos(basic_iterator<Cur> & it) noexcept
        {
            return it.pos();
        }
        template<typename Cur>
        static constexpr Cur const & pos(basic_iterator<Cur> const & it) noexcept
        {
            return it.pos();
        }
        template<typename Cur>
        static constexpr Cur && pos(basic_iterator<Cur> && it) noexcept
        {
            return detail::move(it.pos());
        }

        template<typename Cur>
        static constexpr Cur cursor(basic_iterator<Cur> it)
        {
            return std::move(it.pos());
        }
        
    };
    

    
    namespace detail
    {
        
        
        
        
        
        
        template<typename T>
        concept cursor =
            semiregular<T> && semiregular<range_access::mixin_base_t<T>> &&
            constructible_from<range_access::mixin_base_t<T>, T> &&
            constructible_from<range_access::mixin_base_t<T>, T const &>;
            
            
            

        
        
        template<typename T>
        concept has_cursor_next_requires_ = requires(T & t) { range_access::next(t); };
#line 250 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T>
        concept has_cursor_next = detail::has_cursor_next_requires_<T>;

        
        
        template<typename S, typename C>
        concept sentinel_for_cursor_requires_ = requires(S & s, C & c) { range_access::equal(c, s), concepts::requires_<convertible_to<decltype( range_access::equal(c, s)), bool>>; };
#line 265 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename S, typename C>
        concept sentinel_for_cursor =
            semiregular<S> &&
            cursor<C> &&
            detail::sentinel_for_cursor_requires_<S, C>;

        
        
        template<typename T>
        concept readable_cursor_requires_ = requires(T & t) { range_access::read(t); };
#line 281 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T>
        concept readable_cursor = detail::readable_cursor_requires_<T>;

        
        
        template<typename T>
        concept has_cursor_arrow_requires_ = requires(T const & t) { range_access::arrow(t); };
#line 294 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T>
        concept has_cursor_arrow = detail::has_cursor_arrow_requires_<T>;

        
        
        template<typename T, typename U>
        concept writable_cursor_requires_ = requires(T & t, U && u) { range_access::write(t, (U &&) u); };
#line 307 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T, typename U>
        concept writable_cursor =
            detail::writable_cursor_requires_<T, U>;

        
        
        template<typename S, typename C>
        concept sized_sentinel_for_cursor_requires_ = requires(S & s, C & c) { range_access::distance_to(c, s), concepts::requires_<signed_integer_like_<decltype( range_access::distance_to(c, s))>>; };
#line 324 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename S, typename C>
        concept sized_sentinel_for_cursor =
            sentinel_for_cursor<S, C> &&
            detail::sized_sentinel_for_cursor_requires_<S, C>;

        
        
        template<typename T, typename U>
        concept output_cursor =
            writable_cursor<T, U> && cursor<T>;

        
        
        template<typename T>
        concept input_cursor =
            readable_cursor<T> && cursor<T> && has_cursor_next<T>;

        
        
        template<typename T>
        concept forward_cursor =
            input_cursor<T> && sentinel_for_cursor<T, T> &&
            !range_access::single_pass_t<uncvref_t<T>>::value;

        
        
        template<typename T>
        concept bidirectional_cursor_requires_ = requires(T & t) { range_access::prev(t); };
#line 358 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T>
        concept bidirectional_cursor =
            forward_cursor<T> &&
            detail::bidirectional_cursor_requires_<T>;

        
        
        template<typename T>
        concept random_access_cursor_requires_ = requires(T & t) { range_access::advance(t, range_access::distance_to(t, t)); };
#line 373 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T>
        concept random_access_cursor =
            bidirectional_cursor<T> && 
            sized_sentinel_for_cursor<T, T> && 
            detail::random_access_cursor_requires_<T>;

         template<class T > requires std::is_lvalue_reference<T>::value
#line 383 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        void is_lvalue_reference(T&&);

        
        
        template<typename T>
        concept contiguous_cursor_requires_ = requires(T & t) { detail::is_lvalue_reference(range_access::read(t)); };
#line 393 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
        
        
        template<typename T>
        concept contiguous_cursor =
            random_access_cursor<T> && 
            range_access::contiguous_t<uncvref_t<T>>::value && 
            detail::contiguous_cursor_requires_<T>;
        

        template<typename Cur, bool IsReadable>
        inline constexpr bool is_writable_cursor_ = true;

        template<typename Cur>
        inline constexpr bool is_writable_cursor_<Cur, true> =
            (bool) writable_cursor<Cur, range_access::cursor_value_t<Cur>>;

        template<typename Cur>
        inline constexpr bool is_writable_cursor_v =
            is_writable_cursor_<Cur, (bool)readable_cursor<Cur>>;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 417 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"

#line 419 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/range_access.hpp"
#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/addressof.hpp"























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 25 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/addressof.hpp"

namespace ranges
{
    
    namespace detail
    {

        using std::addressof;






































#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/addressof.hpp"
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 77 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/addressof.hpp"

#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/addressof.hpp"
#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"



























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"




















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"




















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"

namespace ranges
{
    
    namespace detail
    {
        namespace _adl_get_
        {
            template<typename>
            void get();

            template<std::size_t I, typename TupleLike>
            constexpr auto adl_get(TupleLike && t) noexcept
                -> decltype(get<I>(static_cast<TupleLike &&>(t)))
            {
                return get<I>(static_cast<TupleLike &&>(t));
            }
            template<typename T, typename TupleLike>
            constexpr auto adl_get(TupleLike && t) noexcept
                -> decltype(get<T>(static_cast<TupleLike &&>(t)))
            {
                return get<T>(static_cast<TupleLike &&>(t));
            }
        } 
        using _adl_get_::adl_get;
    } 

    namespace _tuple_wrapper_
    {
        template<typename TupleLike>
        struct forward_tuple_interface : TupleLike
        {
            forward_tuple_interface() = default;
            using TupleLike::TupleLike;

            
            constexpr forward_tuple_interface (TupleLike && base) noexcept(std::is_nothrow_move_constructible<TupleLike>::value) requires move_constructible<TupleLike>
#line 61 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
              : TupleLike(static_cast<TupleLike &&>(base))
            {}
            
            constexpr forward_tuple_interface (TupleLike const & base) noexcept(std::is_nothrow_copy_constructible<TupleLike>::value) requires copy_constructible<TupleLike>
#line 67 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
              : TupleLike(base)
            {}
















#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"

            
            template<std::size_t I, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> &wb) noexcept(noexcept(detail::adl_get<I>(static_cast<U &>(wb)))) -> decltype(detail::adl_get<I>(static_cast<U &>(wb))) { return (detail::adl_get<I>(static_cast<U &>(wb))); }
#line 94 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<std::size_t I, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> const &wb) noexcept(noexcept(detail::adl_get<I>(static_cast<U const &>(wb)))) -> decltype(detail::adl_get<I>(static_cast<U const &>(wb))) { return (detail::adl_get<I>(static_cast<U const &>(wb))); }
#line 100 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<std::size_t I, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> &&wb) noexcept(noexcept(detail::adl_get<I>(static_cast<U &&>(wb)))) -> decltype(detail::adl_get<I>(static_cast<U &&>(wb))) { return (detail::adl_get<I>(static_cast<U &&>(wb))); }
#line 106 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<std::size_t I, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> const &&wb) noexcept(noexcept(detail::adl_get<I>(static_cast<U const &&>(wb)))) -> decltype(detail::adl_get<I>(static_cast<U const &&>(wb))) { return (detail::adl_get<I>(static_cast<U const &&>(wb))); }
#line 112 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<typename T, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> &wb) noexcept(noexcept(detail::adl_get<T>(static_cast<U &>(wb)))) -> decltype(detail::adl_get<T>(static_cast<U &>(wb))) { return (detail::adl_get<T>(static_cast<U &>(wb))); }
#line 118 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<typename T, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> const &wb) noexcept(noexcept(detail::adl_get<T>(static_cast<U const &>(wb)))) -> decltype(detail::adl_get<T>(static_cast<U const &>(wb))) { return (detail::adl_get<T>(static_cast<U const &>(wb))); }
#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<typename T, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> &&wb) noexcept(noexcept(detail::adl_get<T>(static_cast<U &&>(wb)))) -> decltype(detail::adl_get<T>(static_cast<U &&>(wb))) { return (detail::adl_get<T>(static_cast<U &&>(wb))); }
#line 130 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            template<typename T, typename U = TupleLike>
            friend constexpr auto get (forward_tuple_interface<TupleLike> const &&wb) noexcept(noexcept(detail::adl_get<T>(static_cast<U const &&>(wb)))) -> decltype(detail::adl_get<T>(static_cast<U const &&>(wb))) { return (detail::adl_get<T>(static_cast<U const &&>(wb))); }
#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
            
        };
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 143 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"

#line 145 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/adl_get.hpp"
#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 24 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"

namespace ranges
{
    
    
    

    
    namespace _get_
    {
        
        
        template<std::size_t I, typename TupleLike>
        constexpr auto get (TupleLike &&t) noexcept(noexcept(detail::adl_get<I>(static_cast<TupleLike &&>(t)))) -> decltype(detail::adl_get<I>(static_cast<TupleLike &&>(t))) { return (detail::adl_get<I>(static_cast<TupleLike &&>(t))); }
#line 41 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"
        template<typename T, typename TupleLike>
        constexpr auto get (TupleLike &&t) noexcept(noexcept(detail::adl_get<T>(static_cast<TupleLike &&>(t)))) -> decltype(detail::adl_get<T>(static_cast<TupleLike &&>(t))) { return (detail::adl_get<T>(static_cast<TupleLike &&>(t))); }
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"
            

            template<typename T>
            T & get(meta::id_t<T> & value) noexcept
        {
            return value;
        }
        template<typename T>
        T const & get(meta::id_t<T> const & value) noexcept
        {
            return value;
        }
        template<typename T>
        T && get(meta::id_t<T> && value) noexcept
        {
            return static_cast<T &&>(value);
        }
        
    } 
    using namespace _get_;
    

    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"

#line 74 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/get.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"

__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4996))

namespace ranges
{
    
    
    

    
    template<typename T>
    struct [[deprecated("The ranges::mutable_ class template is deprecated")]] mutable_
    {
        mutable T value;

        
        constexpr mutable_ () requires std::is_default_constructible<T>::value
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
          : value{}
        {}
        constexpr explicit mutable_(T const & t)
          : value(t)
        {}
        constexpr explicit mutable_(T && t)
          : value(detail::move(t))
        {}
        mutable_ const & operator=(T const & t) const
        {
            value = t;
            return *this;
        }
        mutable_ const & operator=(T && t) const
        {
            value = detail::move(t);
            return *this;
        }
        constexpr operator T &() const &
        {
            return value;
        }
    };

    template<typename T, T v>
    struct [[deprecated("The ranges::constant class template is deprecated")]] constant
    {
        constant() = default;
        constexpr explicit constant(T const &)
        {}
        constant & operator=(T const &)
        {
            return *this;
        }
        constant const & operator=(T const &) const
        {
            return *this;
        }
        constexpr operator T() const
        {
            return v;
        }
        constexpr T exchange(T const &) const
        {
            return v;
        }
    };
    

    
    namespace detail
    {
        
        enum class box_compress
        {
            none, 
            ebo,  
                  
            coalesce 
                     
        };

        
        
        
        
        template<typename Fn>
        using could_be_lambda = meta::bool_<!std::is_default_constructible<Fn>::value &&
                                            !std::is_copy_assignable<Fn>::value>;

        template<typename>
        constexpr box_compress box_compression_(...)
        {
            return box_compress::none;
        }
        template<typename T, typename = meta::if_<meta::strict_and<
                                 std::is_empty<T>,
                                 meta::bool_<!detail::is_final_v<T>>







#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
                                 >>>
        constexpr box_compress box_compression_(long)
        {
            return box_compress::ebo;
        }











        template<typename T>
        constexpr box_compress box_compression()
        {
            return box_compression_<T>(0);
        }
    } 
    

    template<typename Element, typename Tag = void,
             detail::box_compress = detail::box_compression<Element>()>
    class box
    {
        Element value;

    public:
        
        constexpr box () noexcept(std::is_nothrow_default_constructible<Element>::value) requires std::is_default_constructible<Element>::value
#line 171 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
          : value{}
        {}

         template<typename E > requires (!same_as<box, detail::decay_t<E>>) && constructible_from<Element, E>
#line 177 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
        constexpr explicit(!convertible_to<E, Element>) box(E && e)
            noexcept(std::is_nothrow_constructible<Element, E>::value) 
          : value(static_cast<E &&>(e))
        {}

















#line 199 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"

        constexpr Element & get() & noexcept
        {
            return value;
        }
        constexpr Element const & get() const & noexcept
        {
            return value;
        }
        constexpr Element && get() && noexcept
        {
            return detail::move(value);
        }
        constexpr Element const && get() const && noexcept
        {
            return detail::move(value);
        }
    };

    template<typename Element, typename Tag>
    class box<Element, Tag, detail::box_compress::ebo> : Element
    {
    public:
        
        constexpr box () noexcept(std::is_nothrow_default_constructible<Element>::value) requires std::is_default_constructible<Element>::value
#line 226 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
          : Element{}
        {}

         template<typename E > requires (!same_as<box, detail::decay_t<E>>) && constructible_from<Element, E>
#line 232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
        constexpr explicit(!convertible_to<E, Element>) box(E && e)
            noexcept(std::is_nothrow_constructible<Element, E>::value) 
          : Element(static_cast<E &&>(e))
        {}

















#line 254 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"

        constexpr Element & get() & noexcept
        {
            return *this;
        }
        constexpr Element const & get() const & noexcept
        {
            return *this;
        }
        constexpr Element && get() && noexcept
        {
            return detail::move(*this);
        }
        constexpr Element const && get() const && noexcept
        {
            return detail::move(*this);
        }
    };

    template<typename Element, typename Tag>
    class box<Element, Tag, detail::box_compress::coalesce>
    {
        static Element value;

    public:
        constexpr box() noexcept = default;


         template<typename E > requires (!same_as<box, detail::decay_t<E>>) && constructible_from<Element, E>
#line 285 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
        constexpr explicit(!convertible_to<E, Element>) box(E &&) noexcept
        {}













#line 301 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"

        constexpr Element & get() & noexcept
        {
            return value;
        }
        constexpr Element const & get() const & noexcept
        {
            return value;
        }
        constexpr Element && get() && noexcept
        {
            return detail::move(value);
        }
        constexpr Element const && get() const && noexcept
        {
            return detail::move(value);
        }
    };

    template<typename Element, typename Tag>
    Element box<Element, Tag, detail::box_compress::coalesce>::value{};

    
    namespace _get_
    {
        
        
        template<typename Tag, typename Element, detail::box_compress BC>
        constexpr Element & get(box<Element, Tag, BC> & b) noexcept
        {
            return b.get();
        }
        template<typename Tag, typename Element, detail::box_compress BC>
        constexpr Element const & get(box<Element, Tag, BC> const & b) noexcept
        {
            return b.get();
        }
        template<typename Tag, typename Element, detail::box_compress BC>
        constexpr Element && get(box<Element, Tag, BC> && b) noexcept
        {
            return detail::move(b).get();
        }
        
        template<std::size_t I, typename Element, detail::box_compress BC>
        constexpr Element & get(box<Element, meta::size_t<I>, BC> & b) noexcept
        {
            return b.get();
        }
        template<std::size_t I, typename Element, detail::box_compress BC>
        constexpr Element const & get(
            box<Element, meta::size_t<I>, BC> const & b) noexcept
        {
            return b.get();
        }
        template<std::size_t I, typename Element, detail::box_compress BC>
        constexpr Element && get(box<Element, meta::size_t<I>, BC> && b) noexcept
        {
            return detail::move(b).get();
        }
        
    } 
    
    
} 

__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 369 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"

#line 371 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/box.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"



























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        template<typename T>
        struct reference_wrapper_
        {
            T * t_ = nullptr;
            constexpr reference_wrapper_() = default;
            constexpr reference_wrapper_(T & t) noexcept
              : t_(detail::addressof(t))
            {}
            constexpr reference_wrapper_(T &&) = delete;
            constexpr T & get() const noexcept
            {
                return *t_;
            }
        };
        template<typename T>
        struct reference_wrapper_<T &> : reference_wrapper_<T>
        {
            using reference_wrapper_<T>::reference_wrapper_;
        };
        template<typename T>
        struct reference_wrapper_<T &&>
        {
            T * t_ = nullptr;
            constexpr reference_wrapper_() = default;
            constexpr reference_wrapper_(T && t) noexcept
              : t_(detail::addressof(t))
            {}
            constexpr T && get() const noexcept
            {
                return static_cast<T &&>(*t_);
            }
        };
    } 
    

    
    
    template<typename T>
    struct reference_wrapper : private detail::reference_wrapper_<T>
    {
    private:
        using base_ = detail::reference_wrapper_<T>;
        using base_::t_;

    public:
        using type = meta::_t<std::remove_reference<T>>;
        using reference = meta::if_<std::is_reference<T>, T, T &>;

        constexpr reference_wrapper() = default;
         template<typename U > requires (!same_as<uncvref_t<U>, reference_wrapper>) && constructible_from<base_, U>
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"
        constexpr reference_wrapper(U && u) noexcept(
            std::is_nothrow_constructible<base_, U>::value)
          : detail::reference_wrapper_<T>{static_cast<U &&>(u)}
        {}
        constexpr reference get() const noexcept
        {
            return this->base_::get();
        }
        constexpr operator reference() const noexcept
        {
            return get();
        }
         template<typename... > requires (!std::is_rvalue_reference<T>::value) 
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"
        constexpr operator std::reference_wrapper<type>() const noexcept
        {
            return {get()};
        }
        
        template<typename ...Args>
        constexpr auto operator() (Args &&...args) const noexcept(noexcept(invoke(static_cast<reference>(*t_), static_cast<Args &&>(args)...))) -> decltype(invoke(static_cast<reference>(*t_), static_cast<Args &&>(args)...)) { return (invoke(static_cast<reference>(*t_), static_cast<Args &&>(args)...)); }
#line 113 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"
        
    };

    struct ref_fn
    {
         template<typename T > requires (!is_reference_wrapper_v<T>) 
#line 120 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"
        constexpr reference_wrapper<T> operator()(T & t) const
        {
            return {t};
        }
        
        template<typename T>
        constexpr reference_wrapper<T> operator()(reference_wrapper<T> t) const
        {
            return t;
        }
        
        template<typename T>
        constexpr reference_wrapper<T> operator()(std::reference_wrapper<T> t) const
        {
            return {t.get()};
        }
    };

    
    
    inline constexpr ref_fn ref{};

    template<typename T>
    using ref_t = decltype(ref(std::declval<T>()));

    struct unwrap_reference_fn
    {
        template<typename T>
        constexpr T && operator()(T && t) const noexcept
        {
            return static_cast<T &&>(t);
        }
        
        template<typename T>
        constexpr typename reference_wrapper<T>::reference operator()(reference_wrapper<T> t) const
            noexcept
        {
            return t.get();
        }
        
        template<typename T>
        constexpr T & operator()(std::reference_wrapper<T> t) const noexcept
        {
            return t.get();
        }
        
        template<typename T>
        constexpr T & operator()(ref_view<T> t) const noexcept
        {
            return t.base();
        }
    };

    
    
    inline constexpr unwrap_reference_fn unwrap_reference{};

    template<typename T>
    using unwrap_reference_t = decltype(unwrap_reference(std::declval<T>()));
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 183 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"

#line 185 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/reference_wrapper.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/in_place.hpp"




















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 22 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/in_place.hpp"

namespace ranges
{
    
    struct in_place_t
    {};
    inline constexpr in_place_t in_place{};
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/in_place.hpp"

#line 34 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/in_place.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"

namespace ranges
{
    
    template<typename T>
    struct semiregular_box;

    namespace detail
    {
        struct semiregular_get
        {
            
            template<typename T>
            friend auto get (meta::id_t<semiregular_box<T>> &t) noexcept(noexcept(t.get())) -> decltype(t.get()) { return (t.get()); }
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
            template<typename T>
            friend auto get (meta::id_t<semiregular_box<T>> const &t) noexcept(noexcept(t.get())) -> decltype(t.get()) { return (t.get()); }
#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
            template<typename T>
            friend auto get (meta::id_t<semiregular_box<T>> &&t) noexcept(noexcept(detail::move(t).get())) -> decltype(detail::move(t).get()) { return (detail::move(t).get()); }
#line 60 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
            
        };
    } 
    

    
    
    template<typename T>
    struct semiregular_box : private detail::semiregular_get
    {
    private:
        struct tag
        {};
        template<typename... Args>
        void construct_from(Args &&... args)
        {
            new((void *)std::addressof(data_)) T(static_cast<Args &&>(args)...);
            engaged_ = true;
        }
        void move_assign(T && t, std::true_type)
        {
            data_ = detail::move(t);
        }
        void move_assign(T && t, std::false_type)
        {
            reset();
            construct_from(detail::move(t));
        }
        void copy_assign(T const & t, std::true_type)
        {
            data_ = t;
        }
        void copy_assign(T && t, std::false_type)
        {
            reset();
            construct_from(t);
        }
        constexpr semiregular_box(tag, std::false_type) noexcept
        {}
        constexpr semiregular_box(tag, std::true_type) noexcept(
            std::is_nothrow_default_constructible<T>::value)
          : data_{}
          , engaged_(true)
        {}
        void reset()
        {
            if(engaged_)
            {
                data_.~T();
                engaged_ = false;
            }
        }
        union
        {
            char ch_{};
            T data_;
        };
        bool engaged_{false};

    public:
        constexpr semiregular_box() noexcept(
            std::is_nothrow_default_constructible<T>::value ||
            !std::is_default_constructible<T>::value)
          : semiregular_box(tag{}, std::is_default_constructible<T>{})
        {}
        semiregular_box(semiregular_box && that) noexcept(
            std::is_nothrow_move_constructible<T>::value)
        {
            if(that.engaged_)
                this->construct_from(detail::move(that.data_));
        }
        semiregular_box(semiregular_box const & that) noexcept(
            std::is_nothrow_copy_constructible<T>::value)
        {
            if(that.engaged_)
                this->construct_from(that.data_);
        }

         template<typename U > requires (!same_as<uncvref_t<U>, semiregular_box>) && constructible_from<T, U>
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        explicit(!convertible_to<U, T>) constexpr semiregular_box(U && u)
            noexcept(std::is_nothrow_constructible<T, U>::value)
          : semiregular_box(in_place, static_cast<U &&>(u))
        {}















#line 161 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
         template<typename... Args > requires constructible_from<T, Args...>
#line 163 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        constexpr semiregular_box(in_place_t, Args &&... args) 
            noexcept(std::is_nothrow_constructible<T, Args...>::value)
          : data_(static_cast<Args &&>(args)...)
          , engaged_(true)
        {}
        ~semiregular_box()
        {
            reset();
        }
        semiregular_box & operator=(semiregular_box && that) noexcept(
            std::is_nothrow_move_constructible<T>::value &&
            (!std::is_move_assignable<T>::value ||
             std::is_nothrow_move_assignable<T>::value))
        {
            if(engaged_ && that.engaged_)
                this->move_assign(detail::move(that.data_), std::is_move_assignable<T>());
            else if(that.engaged_)
                this->construct_from(detail::move(that.data_));
            else if(engaged_)
                this->reset();
            return *this;
        }
        semiregular_box & operator=(semiregular_box const & that) noexcept(
            std::is_nothrow_copy_constructible<T>::value &&
            (!std::is_copy_assignable<T>::value ||
             std::is_nothrow_copy_assignable<T>::value))
        {
            if(engaged_ && that.engaged_)
                this->copy_assign(that.data_, std::is_copy_assignable<T>());
            else if(that.engaged_)
                this->construct_from(that.data_);
            else if(engaged_)
                this->reset();
            return *this;
        }
        constexpr T & get() & noexcept
        {
            return static_cast<void>((((engaged_)) && "engaged_") ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp", 200, "assertion failed: " "((engaged_)) && \"engaged_\"")), data_;
        }
        constexpr T const & get() const & noexcept
        {
            return static_cast<void>((((engaged_)) && "engaged_") ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp", 204, "assertion failed: " "((engaged_)) && \"engaged_\"")), data_;
        }
        constexpr T && get() && noexcept
        {
            return static_cast<void>((((engaged_)) && "engaged_") ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp", 208, "assertion failed: " "((engaged_)) && \"engaged_\"")), detail::move(data_);
        }
        T const && get() const && = delete;
        constexpr operator T &() & noexcept
        {
            return get();
        }
        constexpr operator T const &() const & noexcept
        {
            return get();
        }
        constexpr operator T &&() && noexcept
        {
            return detail::move(get());
        }
        operator T const &&() const && = delete;
        
         template<typename... Args > requires invocable<T &, Args...>
#line 227 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        constexpr decltype(auto) operator()(Args &&... args) &
            noexcept(is_nothrow_invocable_v<T &, Args...>)
        {
            return invoke(data_, static_cast<Args &&>(args)...);
        }
         template<typename... Args > requires invocable<T const &, Args...>
#line 234 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        constexpr decltype(auto) operator()(Args &&... args) const &
            noexcept(is_nothrow_invocable_v<T const &, Args...>)
        {
            return invoke(data_, static_cast<Args &&>(args)...);
        }
         template<typename... Args > requires invocable<T, Args...>
#line 241 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        constexpr decltype(auto) operator()(Args &&... args) &&
            noexcept(is_nothrow_invocable_v<T, Args...>)
        {
            return invoke(static_cast<T &&>(data_), static_cast<Args &&>(args)...);
        }
        template<typename... Args>
        void operator()(Args &&...) const && = delete;
        
    };

    template<typename T>
    struct semiregular_box<T &>
      : private ranges::reference_wrapper<T &>
      , private detail::semiregular_get
    {
        semiregular_box() = default;
         template<typename Arg > requires constructible_from<ranges::reference_wrapper<T &>, Arg &>
#line 259 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        semiregular_box(in_place_t, Arg & arg) noexcept 
          : ranges::reference_wrapper<T &>(arg)
        {}
        using ranges::reference_wrapper<T &>::get;
        using ranges::reference_wrapper<T &>::operator T &;
        using ranges::reference_wrapper<T &>::operator();


         template<typename U > requires (!same_as<uncvref_t<U>, semiregular_box>) && constructible_from<ranges::reference_wrapper<T &>, U>
#line 270 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        constexpr semiregular_box(U && u) noexcept(
            std::is_nothrow_constructible<ranges::reference_wrapper<T &>, U>::value)
          : ranges::reference_wrapper<T &>{static_cast<U &&>(u)}
        {}


#line 277 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
    };

    template<typename T>
    struct semiregular_box<T &&>
      : private ranges::reference_wrapper<T &&>
      , private detail::semiregular_get
    {
        semiregular_box() = default;
         template<typename Arg > requires constructible_from<ranges::reference_wrapper<T &&>, Arg>
#line 287 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        semiregular_box(in_place_t, Arg && arg) noexcept 
          : ranges::reference_wrapper<T &&>(static_cast<Arg &&>(arg))
        {}
        using ranges::reference_wrapper<T &&>::get;
        using ranges::reference_wrapper<T &&>::operator T &&;
        using ranges::reference_wrapper<T &&>::operator();


         template<typename U > requires (!same_as<uncvref_t<U>, semiregular_box>) && constructible_from<ranges::reference_wrapper<T &&>, U>
#line 298 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        constexpr semiregular_box(U && u) noexcept(
            std::is_nothrow_constructible<ranges::reference_wrapper<T &&>, U>::value)
          : ranges::reference_wrapper<T &&>{static_cast<U &&>(u)}
        {}


#line 305 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
    };

    template<typename T>
    using semiregular_box_t = meta::if_c<(bool)semiregular<T>, T, semiregular_box<T>>;

    template<typename T, bool IsConst = false>
    using semiregular_box_ref_or_val_t = meta::if_c<
        (bool)semiregular<T>,
        meta::if_c<IsConst || std::is_empty<T>::value, T, reference_wrapper<T>>,
        reference_wrapper<
            meta::if_c<IsConst, semiregular_box<T> const, semiregular_box<T>>>>;
    

    
    template<typename T>
    using semiregular_t [[deprecated("Please use semiregular_box_t instead.")]] =
        semiregular_box_t<T>;

    template<typename T, bool IsConst = false>
    using semiregular_ref_or_val_t [[deprecated("Please use semiregular_box_ref_or_val_t instead.")]] =
#line 326 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
        semiregular_box_ref_or_val_t<T, IsConst>;
    

} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 332 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"

#line 334 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/semiregular_box.hpp"
#pragma external_header(pop)
#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 36 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4522))

namespace ranges
{
    
    
    
    template<typename T>
    struct basic_mixin : private box<T>
    {
        
        constexpr basic_mixin () noexcept(std::is_nothrow_default_constructible<T>::value) requires default_constructible<T>
#line 52 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
          : box<T>{}
        {}
        
        constexpr explicit basic_mixin (T && t) noexcept(std::is_nothrow_move_constructible<T>::value) requires move_constructible<T>
#line 58 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
          : box<T>(detail::move(t))
        {}
        
        constexpr explicit basic_mixin (T const & t) noexcept(std::is_nothrow_copy_constructible<T>::value) requires copy_constructible<T>
#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
          : box<T>(t)
        {}

    protected:
        using box<T>::get;
    };

    
    namespace detail
    {
        template<typename Cur>
        using cursor_reference_t =
            decltype(range_access::read(std::declval<Cur const &>()));

        
        template<typename Cur>
        auto cursor_move(Cur const & cur, int) -> decltype(range_access::move(cur));
        template<typename Cur>
        auto cursor_move(Cur const & cur, long) -> aux::move_t<cursor_reference_t<Cur>>;

        template<typename Cur>
        using cursor_rvalue_reference_t =
            decltype(detail::cursor_move(std::declval<Cur const &>(), 42));

        
        
        
        template<typename Derived, typename Head>
        struct proxy_reference_conversion
        {
            operator Head() const
                noexcept(noexcept(Head(Head(std::declval<Derived const &>().read_()))))
            {
                return Head(static_cast<Derived const *>(this)->read_());
            }
        };

        
        template<typename Cur, bool IsReadable>
        struct cursor_traits_
        {
        private:
            struct private_
            {};

        public:
            using value_t_ = private_;
            using reference_t_ = private_;
            using rvalue_reference_t_ = private_;
            using common_refs = meta::list<>;
        };

        template<typename Cur>
        struct cursor_traits_<Cur, true>
        {
            using value_t_ = range_access::cursor_value_t<Cur>;
            using reference_t_ = cursor_reference_t<Cur>;
            using rvalue_reference_t_ = cursor_rvalue_reference_t<Cur>;

        private:
            using R1 = reference_t_;
            using R2 = common_reference_t<reference_t_, value_t_ &>;
            using R3 = common_reference_t<reference_t_, rvalue_reference_t_>;
            using tmp1 = meta::list<value_t_, R1>;
            using tmp2 =
                meta::if_<meta::in<tmp1, uncvref_t<R2>>, tmp1, meta::push_back<tmp1, R2>>;
            using tmp3 =
                meta::if_<meta::in<tmp2, uncvref_t<R3>>, tmp2, meta::push_back<tmp2, R3>>;

        public:
            using common_refs = meta::unique<meta::pop_front<tmp3>>;
        };

        template<typename Cur>
        using cursor_traits = cursor_traits_<Cur, (bool)readable_cursor<Cur>>;

        template<typename Cur>
        using cursor_value_t = typename cursor_traits<Cur>::value_t_;

        template<typename Cur, bool IsReadable>
        struct basic_proxy_reference_;
        template<typename Cur>
        using basic_proxy_reference =
            basic_proxy_reference_<Cur, (bool)readable_cursor<Cur>>;

        
        
        
        template<typename Cur, bool IsReadable >
        struct __declspec(empty_bases) basic_proxy_reference_
          : cursor_traits<Cur>
          
          
          , meta::inherit<meta::transform<
                typename cursor_traits<Cur>::common_refs,
                meta::bind_front<meta::quote<proxy_reference_conversion>,
                                 basic_proxy_reference_<Cur, IsReadable>>>>
        {
        private:
            Cur * cur_;
            template<typename, bool>
            friend struct basic_proxy_reference_;
            template<typename, typename>
            friend struct proxy_reference_conversion;
            using typename cursor_traits<Cur>::value_t_;
            using typename cursor_traits<Cur>::reference_t_;
            using typename cursor_traits<Cur>::rvalue_reference_t_;
            static_assert((bool)common_reference_with<value_t_ &, reference_t_>,
                          "Your readable and writable cursor must have a value type and "
                          "a reference type that share a common reference type. See the "
                          "ranges::common_reference type trait.");
            
        public:
            constexpr reference_t_ read_() const noexcept(
                noexcept(reference_t_(range_access::read(std::declval<Cur const &>()))))
            {
                return range_access::read(*cur_);
            }
            template<typename T>
            constexpr void write_(T && t) const
            {
                range_access::write(*cur_, (T &&) t);
            }
            
            basic_proxy_reference_() = default;
            basic_proxy_reference_(basic_proxy_reference_ const &) = default;
             template<typename OtherCur > requires convertible_to<OtherCur *, Cur *>
#line 192 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_(
                basic_proxy_reference<OtherCur> const & that) noexcept
              : cur_(that.cur_)
            {}
            constexpr explicit basic_proxy_reference_(Cur & cur) noexcept
              : cur_(&cur)
            {}
            
            constexpr auto operator=(basic_proxy_reference_ && that)
                -> basic_proxy_reference_ & requires readable_cursor<Cur>
#line 203 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            {
                return *this = that;
            }
            
            constexpr auto operator=(basic_proxy_reference_ const & that)
                -> basic_proxy_reference_ & requires readable_cursor<Cur>
#line 210 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            {
                this->write_(that.read_());
                return *this;
            }
            
            constexpr auto operator=(basic_proxy_reference_ && that) const
                -> basic_proxy_reference_ const & requires readable_cursor<Cur>
#line 218 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            {
                return *this = that;
            }
            
            constexpr auto operator=(basic_proxy_reference_ const & that) const
                -> basic_proxy_reference_ const & requires readable_cursor<Cur>
#line 225 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            {
                this->write_(that.read_());
                return *this;
            }
             template<typename OtherCur > requires readable_cursor<OtherCur> && writable_cursor<Cur, cursor_reference_t<OtherCur>>
#line 232 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_ & 
            operator=(basic_proxy_reference<OtherCur> && that)
            {
                return *this = that;
            }
             template<typename OtherCur > requires readable_cursor<OtherCur> && writable_cursor<Cur, cursor_reference_t<OtherCur>>
#line 240 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_ & 
            operator=(basic_proxy_reference<OtherCur> const & that)
            {
                this->write_(that.read_());
                return *this;
            }
             template<typename OtherCur > requires readable_cursor<OtherCur> && writable_cursor<Cur, cursor_reference_t<OtherCur>>
#line 249 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_ const & 
            operator=(basic_proxy_reference<OtherCur> && that) const
            {
                return *this = that;
            }
             template<typename OtherCur > requires readable_cursor<OtherCur> && writable_cursor<Cur, cursor_reference_t<OtherCur>>
#line 257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_ const & 
            operator=(basic_proxy_reference<OtherCur> const & that) const
            {
                this->write_(that.read_());
                return *this;
            }
             template<typename T > requires writable_cursor<Cur, T>
#line 265 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_ & operator=(T && t) 
            {
                this->write_((T &&) t);
                return *this;
            }
             template<typename T > requires writable_cursor<Cur, T>
#line 272 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
            constexpr basic_proxy_reference_ const & operator=(T && t) const
            {
                this->write_((T &&) t);
                return *this;
            }
        };

         template<typename Cur, bool IsReadable > requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>
#line 281 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr bool operator==(basic_proxy_reference_<Cur, IsReadable> const & x,
                                  cursor_value_t<Cur> const & y)
        {
            return x.read_() == y;
        }
         template<typename Cur, bool IsReadable > requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>
#line 288 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr bool operator!=(basic_proxy_reference_<Cur, IsReadable> const & x,
                                  cursor_value_t<Cur> const & y)
        {
            return !(x == y);
        }
         template<typename Cur, bool IsReadable > requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>
#line 295 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr bool operator==(cursor_value_t<Cur> const & x,
                                  basic_proxy_reference_<Cur, IsReadable> const & y)
        {
            return x == y.read_();
        }
         template<typename Cur, bool IsReadable > requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>
#line 302 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr bool operator!=(cursor_value_t<Cur> const & x,
                                  basic_proxy_reference_<Cur, IsReadable> const & y)
        {
            return !(x == y);
        }
         template<typename Cur, bool IsReadable > requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>
#line 309 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr bool operator==(basic_proxy_reference_<Cur, IsReadable> const & x,
                                  basic_proxy_reference_<Cur, IsReadable> const & y)
        {
            return x.read_() == y.read_();
        }
         template<typename Cur, bool IsReadable > requires readable_cursor<Cur> && equality_comparable<cursor_value_t<Cur>>
#line 316 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr bool operator!=(basic_proxy_reference_<Cur, IsReadable> const & x,
                                  basic_proxy_reference_<Cur, IsReadable> const & y)
        {
            return !(x == y);
        }

        template<typename Cur>
        using cpp20_iter_cat_of_t =                             
            std::enable_if_t<                                   
                input_cursor<Cur>,                              
                meta::conditional_t<                            
                    contiguous_cursor<Cur>,                     
                    ranges::contiguous_iterator_tag,            
                    meta::conditional_t<                        
                        random_access_cursor<Cur>,              
                        std::random_access_iterator_tag,        
                        meta::conditional_t<                    
                            bidirectional_cursor<Cur>,          
                            std::bidirectional_iterator_tag,    
                            meta::conditional_t<                
                                forward_cursor<Cur>,            
                                std::forward_iterator_tag,      
                                std::input_iterator_tag>>>>>;

        
        
        
         template<typename C > concept cpp17_input_cursor_concept_ = !range_access::single_pass_t<uncvref_t<C>>::value || (move_constructible<range_access::cursor_value_t<C>> && constructible_from<range_access::cursor_value_t<C>, cursor_reference_t<C>>);
#line 351 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

        
        
        template<typename C>
        concept cpp17_input_cursor =
            input_cursor<C> &&
            sentinel_for_cursor<C, C> &&
            cpp17_input_cursor_concept_<C>;

        
        
         template<typename C > concept cpp17_forward_cursor_concept_ = std::is_reference<cursor_reference_t<C>>::value;
#line 366 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

        
        
        template<typename C>
        concept cpp17_forward_cursor =
            forward_cursor<C> &&
            cpp17_forward_cursor_concept_<C>;
        

        template<typename Category, typename Base = void>
        struct with_iterator_category : Base
        {
            using iterator_category = Category;
        };

        template<typename Category>
        struct with_iterator_category<Category>
        {
            using iterator_category = Category;
        };

        template<typename Cur>
        using cpp17_iter_cat_of_t =                      
            std::enable_if_t<                            
                cpp17_input_cursor<Cur>,                 
                meta::conditional_t<                       
                    random_access_cursor<Cur>,           
                    std::random_access_iterator_tag,     
                    meta::conditional_t<                   
                        bidirectional_cursor<Cur>,       
                        std::bidirectional_iterator_tag, 
                        meta::conditional_t<               
                            cpp17_forward_cursor<Cur>,   
                            std::forward_iterator_tag,   
                            std::input_iterator_tag>>>>;

        template<typename Cur, typename = void>
        struct readable_iterator_associated_types_base : range_access::mixin_base_t<Cur>
        {
            readable_iterator_associated_types_base() = default;
            using range_access::mixin_base_t<Cur>::mixin_base_t;
            readable_iterator_associated_types_base(Cur && cur)
              : range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
            {}
            readable_iterator_associated_types_base(Cur const & cur)
              : range_access::mixin_base_t<Cur>(cur)
            {}
        };

        template<typename Cur>
        struct readable_iterator_associated_types_base<
            Cur, always_<void, cpp17_iter_cat_of_t<Cur>>>
          : range_access::mixin_base_t<Cur>
        {
            using iterator_category = cpp17_iter_cat_of_t<Cur>;
            readable_iterator_associated_types_base() = default;
            using range_access::mixin_base_t<Cur>::mixin_base_t;
            readable_iterator_associated_types_base(Cur && cur)
              : range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
            {}
            readable_iterator_associated_types_base(Cur const & cur)
              : range_access::mixin_base_t<Cur>(cur)
            {}
        };

        template<typename Cur, bool IsReadable >
        struct iterator_associated_types_base_ : range_access::mixin_base_t<Cur>
        {
            
            
            using iter_reference_t = basic_proxy_reference<Cur>;
            using const_reference_t = basic_proxy_reference<Cur const>;

        public:
            using reference = void;
            using difference_type = range_access::cursor_difference_t<Cur>;

            iterator_associated_types_base_() = default;
            using range_access::mixin_base_t<Cur>::mixin_base_t;
            iterator_associated_types_base_(Cur && cur)
              : range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
            {}
            iterator_associated_types_base_(Cur const & cur)
              : range_access::mixin_base_t<Cur>(cur)
            {}
        };

        template<typename Cur>
        using cursor_arrow_t = decltype(range_access::arrow(std::declval<Cur const &>()));

        template<typename Cur>
        struct iterator_associated_types_base_<Cur, true>
          : readable_iterator_associated_types_base<Cur>
        {
            
            
            using iter_reference_t =
                meta::conditional_t<is_writable_cursor_v<Cur const>,
                          basic_proxy_reference<Cur const>,
                          meta::conditional_t<is_writable_cursor_v<Cur>,
                                    basic_proxy_reference<Cur>, cursor_reference_t<Cur>>>;
            using const_reference_t =
                meta::conditional_t<is_writable_cursor_v<Cur const>,
                          basic_proxy_reference<Cur const>, cursor_reference_t<Cur>>;

        public:
            using difference_type = range_access::cursor_difference_t<Cur>;
            using value_type = range_access::cursor_value_t<Cur>;
            using reference = iter_reference_t;
            using iterator_concept = cpp20_iter_cat_of_t<Cur>;
            using pointer = meta::_t<
                meta::conditional_t<
                    (bool)has_cursor_arrow<Cur>,
                    meta::defer<cursor_arrow_t, Cur>,
                    std::add_pointer<reference>>>;
            using common_reference = common_reference_t<reference, value_type &>;

            iterator_associated_types_base_() = default;
            using readable_iterator_associated_types_base<
                Cur>::readable_iterator_associated_types_base;
            iterator_associated_types_base_(Cur && cur)
              : readable_iterator_associated_types_base<Cur>(static_cast<Cur &&>(cur))
            {}
            iterator_associated_types_base_(Cur const & cur)
              : readable_iterator_associated_types_base<Cur>(cur)
            {}
        };

        template<typename Cur>
        using iterator_associated_types_base =
            iterator_associated_types_base_<Cur, (bool)readable_cursor<Cur>>;

        template<typename Value>
        struct postfix_increment_proxy
        {
        private:
            Value cache_;

        public:
            template<typename T>
            constexpr postfix_increment_proxy(T && t)
              : cache_(static_cast<T &&>(t))
            {}
            constexpr Value const & operator*() const noexcept
            {
                return cache_;
            }
        };
    } 
    








#line 525 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

    template<typename Cur>
    struct __declspec(empty_bases) basic_iterator
      : detail::iterator_associated_types_base<Cur>


#line 532 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    {
    private:
        template<typename>
        friend struct basic_iterator;
        friend range_access;
        using base_t = detail::iterator_associated_types_base<Cur>;
        using mixin_t = range_access::mixin_base_t<Cur>;
        static_assert((bool)detail::cursor<Cur>, "");
        using assoc_types_ = detail::iterator_associated_types_base<Cur>;
        using typename assoc_types_::const_reference_t;
        using typename assoc_types_::iter_reference_t;
        constexpr Cur & pos() noexcept
        {
            return this->mixin_t::basic_mixin::get();
        }
        constexpr Cur const & pos() const noexcept
        {
            return this->mixin_t::basic_mixin::get();
        }

    public:
        using typename assoc_types_::difference_type;
        constexpr basic_iterator() = default;
         template<typename OtherCur > requires (!same_as<OtherCur, Cur>) && convertible_to<OtherCur, Cur> && constructible_from<mixin_t, OtherCur>
#line 558 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr basic_iterator(basic_iterator<OtherCur> that)
          : base_t{std::move(that.pos())}
        {}
        
        using base_t::base_t;

        explicit basic_iterator(Cur && cur)
          : base_t(static_cast<Cur &&>(cur))
        {}

        explicit basic_iterator(Cur const & cur)
          : base_t(cur)
        {}

         template<typename OtherCur > requires (!same_as<OtherCur, Cur>) && convertible_to<OtherCur, Cur>
#line 574 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr basic_iterator & operator=(basic_iterator<OtherCur> that)
        {
            pos() = std::move(that.pos());
            return *this;
        }

        
        constexpr auto operator*() const
            noexcept(noexcept(range_access::read(std::declval<Cur const &>())))
            -> const_reference_t requires detail::readable_cursor<Cur> && (!detail::is_writable_cursor_v<Cur>)
#line 586 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return range_access::read(pos());
        }
        
        constexpr auto operator*() 
            noexcept(noexcept(iter_reference_t{std::declval<Cur &>()})) 
            -> iter_reference_t requires detail::has_cursor_next<Cur> && detail::is_writable_cursor_v<Cur>
#line 595 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return iter_reference_t{pos()};
        }
        
        constexpr auto operator*() const
            noexcept(noexcept(const_reference_t{std::declval<Cur const &>()}))
            -> const_reference_t requires detail::has_cursor_next<Cur> && detail::is_writable_cursor_v<Cur const>
#line 604 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return const_reference_t{pos()};
        }
        
        constexpr auto operator*() noexcept 
            -> basic_iterator & requires (!detail::has_cursor_next<Cur>)
#line 611 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return *this;
        }

        
         template<typename C = Cur > requires detail::has_cursor_arrow<C>
#line 618 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr detail::cursor_arrow_t<C> operator-> () const
            noexcept(noexcept(range_access::arrow(std::declval<C const &>())))
        {
            return range_access::arrow(pos());
        }
        
        
         template<typename C = Cur > requires (!detail::has_cursor_arrow<C>) && detail::readable_cursor<C> && std::is_lvalue_reference<const_reference_t>::value && same_as<typename detail::iterator_associated_types_base<C>::value_type, uncvref_t<const_reference_t>>
#line 630 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr std::add_pointer_t<const_reference_t> operator-> () const
            noexcept(noexcept(*std::declval<basic_iterator const &>()))
        {
            return detail::addressof(**this);
        }

        
        constexpr auto operator++() 
            -> basic_iterator & requires detail::has_cursor_next<Cur>
#line 640 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            range_access::next(pos());
            return *this;
        }
        
        constexpr auto operator++() noexcept 
            -> basic_iterator & requires (!detail::has_cursor_next<Cur>)
#line 648 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return *this;
        }

    private:
        constexpr basic_iterator post_increment_(std::false_type, int)
        {
            basic_iterator tmp{*this};
            ++*this;
            return tmp;
        }
        
        
         template<typename A = assoc_types_, typename V = typename A::value_type > requires constructible_from<V, typename A::reference> && move_constructible<V>
#line 664 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        constexpr auto post_increment_(std::true_type, int) 
            -> detail::postfix_increment_proxy<V>
        {
            detail::postfix_increment_proxy<V> p{**this};
            ++*this;
            return p;
        }
        constexpr void post_increment_(std::true_type, long)
        {
            ++*this;
        }

    public:
        
        constexpr auto operator++(int)
        {
            return this->post_increment_(meta::bool_ < detail::input_cursor<Cur> &&
                                             !detail::forward_cursor<Cur>> {},
                                         0);
        }

        
        constexpr auto operator--()
            -> basic_iterator & requires detail::bidirectional_cursor<Cur>
#line 689 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            range_access::prev(pos());
            return *this;
        }
        
        constexpr auto operator--(int) 
            -> basic_iterator requires detail::bidirectional_cursor<Cur>
#line 697 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            basic_iterator tmp(*this);
            --*this;
            return tmp;
        }
        
        constexpr auto operator+=(difference_type n) 
            -> basic_iterator & requires detail::random_access_cursor<Cur>
#line 706 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            range_access::advance(pos(), n);
            return *this;
        }
        
        constexpr auto operator-=(difference_type n) 
            -> basic_iterator & requires detail::random_access_cursor<Cur>
#line 714 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            range_access::advance(pos(), (difference_type)-n);
            return *this;
        }
        
        constexpr auto operator[](difference_type n) const 
            -> const_reference_t requires detail::random_access_cursor<Cur>
#line 722 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return *(*this + n);
        }


        
        
        template<typename C = Cur>
        friend constexpr auto iter_move(basic_iterator const & it) noexcept(
            noexcept(range_access::move(std::declval<C const &>())))
            -> ::concepts::return_t< decltype(range_access::move(std::declval<C const &>())), std::enable_if_t<( same_as<C, Cur> && detail::input_cursor<Cur> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 735 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
        {
            return range_access::move(it.pos());
        }
#line 739 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    };

     template<typename Cur, typename Cur2 > requires detail::sentinel_for_cursor<Cur2, Cur>
#line 743 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator==(basic_iterator<Cur> const & left,
                              basic_iterator<Cur2> const & right)
    {
        return range_access::equal(range_access::pos(left), range_access::pos(right));
    }
     template<typename Cur, typename Cur2 > requires detail::sentinel_for_cursor<Cur2, Cur>
#line 750 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator!=(basic_iterator<Cur> const & left,
                              basic_iterator<Cur2> const & right)
    {
        return !(left == right);
    }
     template<typename Cur, typename S > requires detail::sentinel_for_cursor<S, Cur>
#line 757 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator==(basic_iterator<Cur> const & left,
                              S const & right)
    {
        return range_access::equal(range_access::pos(left), right);
    }
     template<typename Cur, typename S > requires detail::sentinel_for_cursor<S, Cur>
#line 764 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator!=(basic_iterator<Cur> const & left,
                              S const & right)
    {
        return !(left == right);
    }
     template<typename S, typename Cur > requires detail::sentinel_for_cursor<S, Cur>
#line 771 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator==(S const & left,
                              basic_iterator<Cur> const & right)
    {
        return right == left;
    }
     template<typename S, typename Cur > requires detail::sentinel_for_cursor<S, Cur>
#line 778 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator!=(S const & left,
                              basic_iterator<Cur> const & right)
    {
        return right != left;
    }

     template<typename Cur > requires detail::random_access_cursor<Cur>
#line 786 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr basic_iterator<Cur> 
    operator+(basic_iterator<Cur> left, typename basic_iterator<Cur>::difference_type n)
    {
        left += n;
        return left;
    }
     template<typename Cur > requires detail::random_access_cursor<Cur>
#line 794 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr basic_iterator<Cur> 
    operator+(typename basic_iterator<Cur>::difference_type n, basic_iterator<Cur> right)
    {
        right += n;
        return right;
    }
     template<typename Cur > requires detail::random_access_cursor<Cur>
#line 802 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr basic_iterator<Cur> 
    operator-(basic_iterator<Cur> left, typename basic_iterator<Cur>::difference_type n)
    {
        left -= n;
        return left;
    }
     template<typename Cur2, typename Cur > requires detail::sized_sentinel_for_cursor<Cur2, Cur>
#line 810 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr typename basic_iterator<Cur>::difference_type 
    operator-(basic_iterator<Cur2> const & left, basic_iterator<Cur> const & right)
    {
        return range_access::distance_to(range_access::pos(right),
                                         range_access::pos(left));
    }
     template<typename S, typename Cur > requires detail::sized_sentinel_for_cursor<S, Cur>
#line 818 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr typename basic_iterator<Cur>::difference_type 
    operator-(S const & left, basic_iterator<Cur> const & right)
    {
        return range_access::distance_to(range_access::pos(right), left);
    }
     template<typename Cur, typename S > requires detail::sized_sentinel_for_cursor<S, Cur>
#line 825 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr typename basic_iterator<Cur>::difference_type 
    operator-(basic_iterator<Cur> const & left, S const & right)
    {
        return -(right - left);
    }
    
     template<typename Left, typename Right > requires detail::sized_sentinel_for_cursor<Right, Left>
#line 833 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator<(basic_iterator<Left> const & left,
                             basic_iterator<Right> const & right)
    {
        return 0 < (right - left);
    }
     template<typename Left, typename Right > requires detail::sized_sentinel_for_cursor<Right, Left>
#line 840 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator<=(basic_iterator<Left> const & left,
                              basic_iterator<Right> const & right)
    {
        return 0 <= (right - left);
    }
     template<typename Left, typename Right > requires detail::sized_sentinel_for_cursor<Right, Left>
#line 847 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator>(basic_iterator<Left> const & left,
                             basic_iterator<Right> const & right)
    {
        return (right - left) < 0;
    }
     template<typename Left, typename Right > requires detail::sized_sentinel_for_cursor<Right, Left>
#line 854 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
    constexpr bool operator>=(basic_iterator<Left> const & left,
                              basic_iterator<Right> const & right)
    {
        return (right - left) <= 0;
    }
















#line 876 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

    
    struct get_cursor_fn
    {
        template<typename Cur>
        constexpr Cur & operator()(basic_iterator<Cur> & it) const noexcept
        {
            return range_access::pos(it);
        }
        template<typename Cur>
        constexpr Cur const & operator()(basic_iterator<Cur> const & it) const noexcept
        {
            return range_access::pos(it);
        }
        template<typename Cur>
        constexpr Cur operator()(basic_iterator<Cur> && it) const
            noexcept(std::is_nothrow_move_constructible<Cur>::value)
        {
            return range_access::pos(std::move(it));
        }
    };

    
    inline constexpr get_cursor_fn get_cursor{};
    
} 


namespace concepts
{
    
    template<typename Cur, typename U, template<typename> class TQual,
             template<typename> class UQual>
    struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
                                  TQual, UQual>
      : basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
    {};
    template<typename T, typename Cur, template<typename> class TQual,
             template<typename> class UQual>
    struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
                                  TQual, UQual>
      : basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
    {};
    template<typename Cur1, typename Cur2, template<typename> class TQual,
             template<typename> class UQual>
    struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
                                  ::ranges::detail::basic_proxy_reference_<Cur2, true>,
                                  TQual, UQual>
      : basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
                               ::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
    {};

    
    template<typename Cur, typename U>
    struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
      : common_type<::ranges::range_access::cursor_value_t<Cur>, U>
    {};
    template<typename T, typename Cur>
    struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
      : common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
    {};
    template<typename Cur1, typename Cur2>
    struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
                       ::ranges::detail::basic_proxy_reference_<Cur2, true>>
      : common_type<::ranges::range_access::cursor_value_t<Cur1>,
                    ::ranges::range_access::cursor_value_t<Cur2>>
    {};
} 


__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))
namespace std {

    template<typename, typename, template <typename> class, template<typename> class>
    struct basic_common_reference;

    
    template<typename Cur, typename U, template<typename> class TQual,
             template<typename> class UQual>
    struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
                                  TQual, UQual>
      : basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
    {};
    template<typename T, typename Cur, template<typename> class TQual,
             template<typename> class UQual>
    struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
                                  TQual, UQual>
      : basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
    {};
    template<typename Cur1, typename Cur2, template<typename> class TQual,
             template<typename> class UQual>
    struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
                                  ::ranges::detail::basic_proxy_reference_<Cur2, true>,
                                  TQual, UQual>
      : basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
                               ::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
    {};

    template<typename...>
    struct common_type;

    
    template<typename Cur, typename U>
    struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
      : common_type<::ranges::range_access::cursor_value_t<Cur>, U>
    {};
    template<typename T, typename Cur>
    struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
      : common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
    {};
    template<typename Cur1, typename Cur2>
    struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
                       ::ranges::detail::basic_proxy_reference_<Cur2, true>>
      : common_type<::ranges::range_access::cursor_value_t<Cur1>,
                    ::ranges::range_access::cursor_value_t<Cur2>>
    {};

}
__pragma(warning(pop))
#line 997 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename Cur, bool IsReadable>
        struct std_iterator_traits_
        {
            using difference_type =
                typename iterator_associated_types_base<Cur>::difference_type;
            using value_type = void;
            using reference = void;
            using pointer = void;
            using iterator_category = std::output_iterator_tag;
            using iterator_concept = std::output_iterator_tag;
        };

        template<typename Cur>
        struct std_iterator_traits_<Cur, true> : iterator_associated_types_base<Cur>
        {};

        template<typename Cur>
        using std_iterator_traits = std_iterator_traits_<Cur, (bool)readable_cursor<Cur>>;
    } 
    
} 

namespace std
{
    template<typename Cur>
    struct iterator_traits<::ranges::basic_iterator<Cur>>
      : ::ranges::detail::std_iterator_traits<Cur>
    {};
} 


__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 1037 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"

#line 1039 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/basic_iterator.hpp"
#pragma external_header(pop)
#line 21 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 24 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        template<typename I>
        struct reverse_cursor
        {
        private:
            static_assert(static_cast<bool>(bidirectional_iterator<I>), "Concept assertion failed : " "bidirectional_iterator<I>");
            friend range_access;

            using value_type = iter_value_t<I>;

            template<typename OtherI>
            friend struct reverse_cursor;
            struct mixin : basic_mixin<reverse_cursor>
            {
                mixin() = default;
                


                constexpr explicit mixin(reverse_cursor && cur)
                  : basic_mixin<reverse_cursor>(static_cast<reverse_cursor &&>(cur))
                {}
                constexpr explicit mixin(reverse_cursor const & cur)
                  : basic_mixin<reverse_cursor>(cur)
                {}
                #line 57 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
                constexpr mixin(I it)
                  : mixin{reverse_cursor{it}}
                {}
                constexpr I base() const
                {
                    return this->get().base();
                }
            };

            I it_;

            constexpr reverse_cursor(I it)
              : it_(std::move(it))
            {}
            constexpr iter_reference_t<I> read() const
            {
                return *arrow();
            }
            constexpr I arrow() const
            {
                auto tmp = it_;
                --tmp;
                return tmp;
            }
            constexpr I base() const
            {
                return it_;
            }
             template<typename J > requires sentinel_for<J, I>
#line 87 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
            constexpr bool equal(reverse_cursor<J> const & that) const
            {
                return it_ == that.it_;
            }
            constexpr void next()
            {
                --it_;
            }
            constexpr void prev()
            {
                ++it_;
            }
            
            constexpr auto advance(iter_difference_t<I> n) 
                -> void requires random_access_iterator<I>
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
            {
                it_ -= n;
            }
             template<typename J > requires sized_sentinel_for<J, I>
#line 108 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
            constexpr iter_difference_t<I> distance_to(reverse_cursor<J> const & that) 
                const
            {
                return it_ - that.base();
            }
            constexpr iter_rvalue_reference_t<I> move() const
                noexcept(noexcept((void)I(I(it_)), (void)--const_cast<I &>(it_),
                                  iter_move(it_)))
            {
                auto tmp = it_;
                --tmp;
                return iter_move(tmp);
            }

        public:
            reverse_cursor() = default;
             template<typename U > requires convertible_to<U, I>
#line 126 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
            constexpr reverse_cursor(reverse_cursor<U> const & u)
              : it_(u.base())
            {}
        };
    } 
    

    struct make_reverse_iterator_fn
    {
         template<typename I > requires bidirectional_iterator<I>
#line 137 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
        constexpr reverse_iterator<I> operator()(I i) const
        {
            return reverse_iterator<I>(i);
        }
    };

    inline constexpr make_reverse_iterator_fn make_reverse_iterator{};

    namespace cpp20
    {
        using ranges::make_reverse_iterator;
        using ranges::reverse_iterator;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 154 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"

#line 156 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/reverse_iterator.hpp"
#pragma external_header(pop)
#line 38 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"

namespace ranges
{

    template<class CharT, class Traits>
    inline constexpr bool
        enable_borrowed_range<std::basic_string_view<CharT, Traits>> = true;
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"




    template<class T, std::size_t N>
    inline constexpr bool enable_borrowed_range<std::span<T, N>> = true;
#line 58 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"

    namespace detail
    {
        template<typename T>
        inline constexpr bool _borrowed_range =
            enable_borrowed_range<uncvref_t<T>>;

        template<typename T>
        inline constexpr bool _borrowed_range<T &> = true;

        template<typename T>
        T _decay_copy(T) noexcept;
    } 

    
    namespace _begin_
    {
        
        
        template<typename T>
        void begin(T &&) = delete;





        template<typename T>
        void begin(std::initializer_list<T>) = delete;

         template<typename I > requires input_or_output_iterator<I>
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        void is_iterator(I);

        
        
        
        template<typename T>
        concept has_member_begin_requires_ = requires(T & t) { _begin_::is_iterator(t.begin()); };
#line 100 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_member_begin =
            _begin_::has_member_begin_requires_<T>;

        
        
        template<typename T>
        concept has_non_member_begin_requires_ = requires(T & t) { _begin_::is_iterator(begin(t)); };
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_non_member_begin =
            _begin_::has_non_member_begin_requires_<T>;
        

        struct fn
        {
        private:
            struct _member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(static_cast<R &(*)() noexcept>(nullptr)().begin()));
            };
            struct _non_member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(begin(static_cast<R &(*)() noexcept>(nullptr)())));
            };

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_begin<R>,
                        _member_result_,
                        _non_member_result_>,
                    R>;

        public:
            template<typename R, std::size_t N>
            void operator()(R(&&)[N]) const = delete;

            template<typename R, std::size_t N>
            constexpr R * operator()(R (&array)[N]) const noexcept
            {
                return array;
            }

             template<typename R > requires detail::_borrowed_range<R> && has_member_begin<R>
#line 156 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr _result_t<R> operator()(R && r) const 
                noexcept(noexcept(r.begin()))
            {
                return r.begin();
            }

             template<typename R > requires detail::_borrowed_range<R> && (!has_member_begin<R>) && has_non_member_begin<R>
#line 165 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr _result_t<R> operator()(R && r) const 
                noexcept(noexcept(begin(r)))
            {
                return begin(r);
            }
        };

        template<typename R>
        using _t = decltype(fn{}(static_cast<R &&(*)() noexcept>(nullptr)()));
    } 
    

    
    
    
    
    
    namespace _ { inline constexpr _begin_::fn begin{}; } using namespace _;

    
    namespace _end_
    {
        
        
        template<typename T>
        void end(T &&) = delete;





        template<typename T>
        void end(std::initializer_list<T>) = delete;

         template<typename I, typename S > requires sentinel_for<S, I>
#line 201 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        void _is_sentinel(S, I);

        
        
        
        template<typename T>
        concept has_member_end_requires_ = requires(T & t) { _end_::_is_sentinel(t.end(), ranges::begin(t)); };
#line 212 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_member_end =
            _end_::has_member_end_requires_<T>;

        
        
        template<typename T>
        concept has_non_member_end_requires_ = requires(T & t) { _end_::_is_sentinel(end(t), ranges::begin(t)); };
#line 226 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_non_member_end =
            _end_::has_non_member_end_requires_<T>;
        

        struct fn
        {
        private:
            struct _member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(static_cast<R &(*)() noexcept>(nullptr)().end()));
            };
            struct _non_member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(end(static_cast<R &(*)() noexcept>(nullptr)())));
            };

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_end<R>,
                        _member_result_,
                        _non_member_result_>,
                    R>;

            template<typename Int>
            using iter_diff_t =
                meta::_t<meta::conditional_t<std::is_integral<Int>::value,
                                             std::make_signed<Int>, 
                                             meta::id<Int>>>;

        public:
            template<typename R, std::size_t N>
            void operator()(R(&&)[N]) const = delete;

            template<typename R, std::size_t N>
            constexpr R * operator()(R (&array)[N]) const noexcept
            {
                return array + N;
            }

             template<typename R > requires detail::_borrowed_range<R> && has_member_end<R>
#line 274 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr _result_t<R> operator()(R && r) const 
                noexcept(noexcept(r.end()))
            {
                return r.end();
            }

             template<typename R > requires detail::_borrowed_range<R> && (!has_member_end<R>) && has_non_member_end<R>
#line 283 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr _result_t<R> operator()(R && r) const 
                noexcept(noexcept(end(r)))
            {
                return end(r);
            }

             template<typename Int > requires detail::integer_like_<Int>
#line 291 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            auto operator-(Int dist) const
                -> detail::from_end_<iter_diff_t<Int>>
            {
                using SInt = iter_diff_t<Int>;
                static_cast<void>((0 <= dist) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp", 295, "assertion failed: " "0 <= dist"));
                static_cast<void>((dist <= static_cast<Int>((std::numeric_limits<SInt>::max)())) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp", 297, "assertion failed: " "dist <= static_cast<Int>((std::numeric_limits<SInt>::max)())"));
#line 298 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
                return detail::from_end_<SInt>{-static_cast<SInt>(dist)};
            }
        };

        template<typename R>
        using _t = decltype(fn{}(static_cast<R &&(*)() noexcept>(nullptr)()));
    } 
    

    
    
    
    
    
    
    namespace _ { inline constexpr _end_::fn end{}; } using namespace _;

    
    namespace _cbegin_
    {
        struct fn
        {
            template<typename T, std::size_t N>
            void operator()(T(&&)[N]) const = delete;

            template<typename R>
            constexpr _begin_::_t<detail::as_const_t<R>> operator()(R && r) const
                noexcept(noexcept(ranges::begin(detail::as_const(r))))
            {
                return ranges::begin(detail::as_const(r));
            }
        };
    } 
    

    
    
    
    
    inline constexpr _cbegin_::fn cbegin{};

    
    namespace _cend_
    {
        struct fn
        {
            template<typename T, std::size_t N>
            void operator()(T(&&)[N]) const = delete;

            template<typename R>
            constexpr _end_::_t<detail::as_const_t<R>> operator()(R && r) const
                noexcept(noexcept(ranges::end(detail::as_const(r))))
            {
                return ranges::end(detail::as_const(r));
            }
        };
    } 
    

    
    
    
    
    inline constexpr _cend_::fn cend{};

    
    namespace _rbegin_
    {
        template<typename R>
        void rbegin(R &&) = delete;
        
        
        template<typename T>
        void rbegin(std::initializer_list<T>) = delete;
        template<typename T, std::size_t N>
        void rbegin(T (&)[N]) = delete;

        
        
        
        template<typename T>
        concept has_member_rbegin_requires_ = requires(T & t) { _begin_::is_iterator(t.rbegin()); };
#line 384 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_member_rbegin =
            _rbegin_::has_member_rbegin_requires_<T>;

        
        
        template<typename T>
        concept has_non_member_rbegin_requires_ = requires(T & t) { _begin_::is_iterator(rbegin(t)); };
#line 398 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_non_member_rbegin =
            _rbegin_::has_non_member_rbegin_requires_<T>;

        template<typename I>
        void _same_type(I, I);

        
        
        template<typename T>
        concept can_reverse_end_requires_ = requires(T & t) { ranges::make_reverse_iterator(ranges::end(t)), _rbegin_::_same_type(ranges::begin(t), ranges::end(t)); };
#line 418 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept can_reverse_end =
            _rbegin_::can_reverse_end_requires_<T>;
        

        struct fn
        {
        private:
            struct _member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(static_cast<R &(*)() noexcept>(nullptr)().rbegin()));
            };
            struct _non_member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(rbegin(static_cast<R &(*)() noexcept>(nullptr)())));
            };
            struct _reverse_result_
            {
                template<typename R>
                using invoke =
                    decltype(ranges::make_reverse_iterator(ranges::end(static_cast<R &(*)() noexcept>(nullptr)())));
            };
            struct _other_result_
            {
                template<typename R>
                using invoke =
                    meta::invoke<
                        meta::conditional_t<
                            has_non_member_rbegin<R>,
                            _non_member_result_,
                            _reverse_result_>,
                        R>;
            };

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_rbegin<R>,
                        _member_result_,
                        _other_result_>,
                    R>;

        public:
             template<typename R > requires detail::_borrowed_range<R> && has_member_rbegin<R>
#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr auto operator()(R && r) const 
                noexcept(noexcept(r.rbegin())) 
            {
                return r.rbegin();
            }

             template<typename R > requires detail::_borrowed_range<R> && (!has_member_rbegin<R>) && has_non_member_rbegin<R>
#line 477 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr auto operator()(R && r) const 
                noexcept(noexcept(rbegin(r))) 
            {
                return rbegin(r);
            }

             template<typename R > requires detail::_borrowed_range<R> && (!has_member_rbegin<R>) && (!has_non_member_rbegin<R>) && can_reverse_end<R>
#line 486 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr auto operator()(R && r) const 
                noexcept(noexcept(ranges::make_reverse_iterator(ranges::end(r))))
            {
                return ranges::make_reverse_iterator(ranges::end(r));
            }
        };

        template<typename R>
        using _t = decltype(fn{}(static_cast<R &&(*)() noexcept>(nullptr)()));
    } 
    

    
    
    
    
    
    
    
    namespace _ { inline constexpr _rbegin_::fn rbegin{}; } using namespace _;

    
    namespace _rend_
    {
        template<typename R>
        void rend(R &&) = delete;
        
        
        template<typename T>
        void rend(std::initializer_list<T>) = delete;
        template<typename T, std::size_t N>
        void rend(T (&)[N]) = delete;

        
        
        
        template<typename T>
        concept has_member_rend_requires_ = requires(T & t) { _end_::_is_sentinel(t.rend(), ranges::rbegin(t)); };
#line 528 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_member_rend =
            _rend_::has_member_rend_requires_<T>;

        
        
        template<typename T>
        concept has_non_member_rend_requires_ = requires(T & t) { _end_::_is_sentinel(rend(t), ranges::rbegin(t)); };
#line 542 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept has_non_member_rend =
            _rend_::has_non_member_rend_requires_<T>;

        
        
        template<typename T>
        concept can_reverse_begin_requires_ = requires(T & t) { ranges::make_reverse_iterator(ranges::begin(t)), _rbegin_::_same_type(ranges::begin(t), ranges::end(t)); };
#line 559 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
        
        
        template<typename T>
        concept can_reverse_begin =
            _rend_::can_reverse_begin_requires_<T>;
        

        struct fn
        {
        private:
            struct _member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(static_cast<R &(*)() noexcept>(nullptr)().rend()));
            };
            struct _non_member_result_
            {
                template<typename R>
                using invoke = decltype(detail::_decay_copy(rend(static_cast<R &(*)() noexcept>(nullptr)())));
            };
            struct _reverse_result_
            {
                template<typename R>
                using invoke =
                    decltype(ranges::make_reverse_iterator(ranges::begin(static_cast<R &(*)() noexcept>(nullptr)())));
            };
            struct _other_result_
            {
                template<typename R>
                using invoke =
                    meta::invoke<
                        meta::conditional_t<
                            has_non_member_rend<R>,
                            _non_member_result_,
                            _reverse_result_>,
                        R>;
            };

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_rend<R>,
                        _member_result_,
                        _other_result_>,
                    R>;

        public:
             template<typename R > requires detail::_borrowed_range<R> && has_member_rend<R>
#line 609 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr auto operator()(R && r) const 
                noexcept(noexcept(r.rend())) 
            {
                return r.rend();
            }

             template<typename R > requires detail::_borrowed_range<R> && (!has_member_rend<R>) && has_non_member_rend<R>
#line 618 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr auto operator()(R && r) const 
                noexcept(noexcept(rend(r))) 
            {
                return rend(r);
            }

             template<typename R > requires detail::_borrowed_range<R> && (!has_member_rend<R>) && (!has_non_member_rend<R>) && can_reverse_begin<R>
#line 627 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
            constexpr auto operator()(R && r) const 
                noexcept(noexcept(ranges::make_reverse_iterator(ranges::begin(r))))
            {
                return ranges::make_reverse_iterator(ranges::begin(r));
            }
        };

        template<typename R>
        using _t = decltype(fn{}(static_cast<R &&(*)() noexcept>(nullptr)()));
    } 
    

    
    
    
    
    
    
    
    
    namespace _ { inline constexpr _rend_::fn rend{}; } using namespace _;

    
    namespace _crbegin_
    {
        struct fn
        {
            template<typename T, std::size_t N>
            void operator()(T(&&)[N]) const = delete;

            template<typename R>
            constexpr _rbegin_::_t<detail::as_const_t<R>> operator()(R && r) const
                noexcept(noexcept(ranges::rbegin(detail::as_const(r))))
            {
                return ranges::rbegin(detail::as_const(r));
            }
        };
    } 
    

    
    
    
    
    inline constexpr _crbegin_::fn crbegin{};

    
    namespace _crend_
    {
        struct fn
        {
            template<typename T, std::size_t N>
            void operator()(T(&&)[N]) const = delete;

            template<typename R>
            constexpr _rend_::_t<detail::as_const_t<R>> operator()(R && r) const
                noexcept(noexcept(ranges::rend(detail::as_const(r))))
            {
                return ranges::rend(detail::as_const(r));
            }
        };
    } 
    

    
    
    
    
    inline constexpr _crend_::fn crend{};

    template<typename Rng>
    using iterator_t = decltype(begin(static_cast<Rng &(*)() noexcept>(nullptr)()));

    template<typename Rng>
    using sentinel_t = decltype(end(static_cast<Rng &(*)() noexcept>(nullptr)()));

    namespace cpp20
    {
        using ranges::begin;
        using ranges::cbegin;
        using ranges::cend;
        using ranges::crbegin;
        using ranges::crend;
        using ranges::end;
        using ranges::rbegin;
        using ranges::rend;

        using ranges::iterator_t;
        using ranges::sentinel_t;

        using ranges::enable_borrowed_range;
    } 
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 722 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"

#line 724 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/access.hpp"
#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"

namespace ranges
{
    
    
    template<typename T>
    inline constexpr bool disable_sized_range = false;

    
    namespace _size_
    {
        template<typename T>
        void size(T &&) = delete;





        
        
        
        template<typename T>
        concept has_member_size_requires_ = requires(T && t) { ((T &&) t).size(); };
#line 54 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
        
        
        template<typename T>
        concept has_member_size =
            _size_::has_member_size_requires_<T>;

        
        
        template<typename T>
        concept has_non_member_size_requires_ = requires(T && t) { size((T &&) t); };
#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
        
        
        template<typename T>
        concept has_non_member_size =
            _size_::has_non_member_size_requires_<T>;
        

        struct fn
        {
        private:
            struct _member_result_
            {
                template<typename R>
                using invoke = decltype(+(static_cast<R &(*)() noexcept>(nullptr)().size()));
            };
            struct _non_member_result_
            {
                template<typename R>
                using invoke = decltype(+(size(static_cast<R &(*)() noexcept>(nullptr)())));
            };
            struct _distance_result_
            {
                template<typename R>
                using invoke = detail::iter_size_t<_begin_::_t<R>>;
            };
            struct _other_result_
            {
                template<typename R>
                using invoke =
                    meta::invoke<
                        meta::conditional_t<
                            has_non_member_size<R>,
                            _non_member_result_,
                            _distance_result_>,
                        R>;
            };

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_size<R>,
                        _member_result_,
                        _other_result_>,
                    R>;

        public:
            template<typename R, std::size_t N>
            constexpr std::size_t operator()(R (&)[N], int) const noexcept
            {
                return N;
            }

            template<typename R, std::size_t N>
            constexpr std::size_t operator()(R(&&)[N]) const noexcept
            {
                return N;
            }

            
             template<typename R > requires (!disable_sized_range<uncvref_t<R>>) && has_member_size<R> && detail::integer_like_<_result_t<R>>
#line 131 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr _result_t<R> operator()(R && r) const
                noexcept(noexcept(((R &&) r).size()))
            {
                return ((R &&) r).size();
            }

            
             template<typename R > requires (!disable_sized_range<uncvref_t<R>>) && (!has_member_size<R>) && has_non_member_size<R> && detail::integer_like_<_result_t<R>>
#line 142 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr _result_t<R> operator()(R && r) const
                noexcept(noexcept(size((R &&) r)))
            {
                return size((R &&) r);
            }

             template<typename R > requires (!has_member_size<R> || disable_sized_range<uncvref_t<R>>) && (!has_non_member_size<R> || disable_sized_range<uncvref_t<R>>) && forward_iterator<_begin_::_t<R>> && sized_sentinel_for<_end_::_t<R>, _begin_::_t<R>>
#line 153 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr _result_t<R> operator()(R && r) const
                noexcept(noexcept(ranges::end((R &&) r) - ranges::begin((R &&) r)))
            {
                using size_type = detail::iter_size_t<_begin_::_t<R>>;
                return static_cast<size_type>(ranges::end((R &&) r) -
                                              ranges::begin((R &&) r));
            }
        };
    } 
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    namespace _ { inline constexpr _size_::fn size{}; } using namespace _;

    
    
    namespace _data_
    {
        
        
        
        template<typename T>
        concept has_member_data_requires_ = requires(T & t) { t.data(); };
#line 201 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
        
        
        template<typename T>
        concept has_member_data =
            _data_::has_member_data_requires_<T>;
        

        struct fn
        {
        private:
            struct _member_data_
            {
                template<typename R>
                using invoke = decltype(+(static_cast<R &&(*)() noexcept>(nullptr)().data()));
            };
            struct _pointer_iterator_
            {
                template<typename R>
                using invoke = _begin_::_t<R>;
            };
            struct _contiguous_iterator_
            {
                template<typename R>
                using invoke = decltype(detail::addressof(*static_cast<_begin_::_t<R> &&(*)() noexcept>(nullptr)()));
            };
            struct _other_result_
            {
                template<typename R>
                using invoke =
                    meta::invoke<
                        meta::conditional_t<
                            std::is_pointer<_begin_::_t<R>>::value,
                            _pointer_iterator_,
                            _contiguous_iterator_>,
                        R>;
            };

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_data<R>,
                        _member_data_,
                        _other_result_>,
                    R>;

        public:
             template<typename R > requires has_member_data<R &> && std::is_pointer<_result_t<R &>>::value
#line 251 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr _result_t<R &> operator()(R & r) const 
                noexcept(noexcept(r.data()))
            {
                return r.data();
            }
             template<typename R > requires (!has_member_data<R &>) && std::is_pointer<_begin_::_t<R>>::value
#line 259 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr _result_t<R> operator()(R && r) const 
                noexcept(noexcept(ranges::begin((R &&) r)))
            {
                return ranges::begin((R &&) r);
            }
             template<typename R > requires (!has_member_data<R &>) && (!std::is_pointer<_begin_::_t<R>>::value) && contiguous_iterator<_begin_::_t<R>>
#line 268 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr _result_t<R> operator()(R && r) const 
                noexcept(noexcept(
                    ranges::begin((R &&) r) == ranges::end((R &&) r)
                      ? nullptr
                      : detail::addressof(*ranges::begin((R &&) r))))
            {
                return ranges::begin((R &&) r) == ranges::end((R &&) r)
                  ? nullptr
                  : detail::addressof(*ranges::begin((R &&) r));
            }









#line 288 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
        };

        template<typename R>
        using _t = decltype(fn{}(static_cast<R &&(*)() noexcept>(nullptr)()));
    } 
    

    inline constexpr _data_::fn data{};

    
    namespace _cdata_
    {
        struct fn
        {
            template<typename R>
            constexpr _data_::_t<R const &> operator()(R const & r) const
                noexcept(noexcept(ranges::data(r)))
            {
                return ranges::data(r);
            }
            template<typename R>
            constexpr _data_::_t<R const> operator()(R const && r) const
                noexcept(noexcept(ranges::data((R const &&)r)))
            {
                return ranges::data((R const &&)r);
            }
        };
    } 
    

    
    
    
    
    inline constexpr _cdata_::fn cdata{};

    
    namespace _empty_
    {
        
        
        
        template<typename T>
        concept has_member_empty_requires_ = requires(T && t) { bool(((T &&) t).empty()); };
#line 336 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
        
        
        template<typename T>
        concept has_member_empty =
            _empty_::has_member_empty_requires_<T>;

        
        
        template<typename T>
        concept has_size_requires_ = requires(T && t) { ranges::size((T &&) t); };
#line 350 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
        
        
        template<typename T>
        concept has_size =
            _empty_::has_size_requires_<T>;
        

        struct fn
        {
            
             template<typename R > requires has_member_empty<R>
#line 362 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr bool operator()(R && r) const
                noexcept(noexcept(bool(((R &&) r).empty())))
            {
                return bool(((R &&) r).empty());
            }

            
             template<typename R > requires (!has_member_empty<R>) && has_size<R>
#line 371 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr bool operator()(R && r) const
                noexcept(noexcept(bool(ranges::size((R &&) r) == 0)))
            {
                return bool(ranges::size((R &&) r) == 0);
            }

            
             template<typename R > requires (!has_member_empty<R>) && (!has_size<R>) && forward_iterator<_begin_::_t<R>>
#line 381 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
            constexpr bool operator()(R && r) const
                noexcept(noexcept(bool(ranges::begin((R &&) r) == ranges::end((R &&) r))))
            {
                return bool(ranges::begin((R &&) r) == ranges::end((R &&) r));
            }
        };
    } 
    

    
    
    inline constexpr _empty_::fn empty{};

    namespace cpp20
    {
        
        using ranges::cdata;
        using ranges::data;
        using ranges::disable_sized_range;
        using ranges::empty;
        using ranges::size;
    } 
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 406 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"

#line 408 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/primitives.hpp"
#pragma external_header(pop)
#line 43 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"




























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename I, typename S>
        using common_iterator_impl_t =
            enable_if_t<(bool)(input_or_output_iterator<I> && sentinel_for<S, I>),
                        common_iterator<I, S>>;
    }
    

    
    
    template<typename I, typename S>
    using common_iterator_t = meta::conditional_t<std::is_same<I, S>::value, I,
                                                detail::common_iterator_impl_t<I, S>>;

    
    namespace detail
    {
        template<typename I, typename S>
        using cpp17_iterator_t =
            meta::conditional_t<std::is_integral<iter_difference_t<I>>::value,
                      common_iterator_t<I, S>, cpp17_iterator<common_iterator_t<I, S>>>;
    }
    

    
    template<typename Rng>
    using range_difference_t = iter_difference_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_value_t = iter_value_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_reference_t = iter_reference_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_common_reference_t = iter_common_reference_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_size_t = decltype(ranges::size(std::declval<Rng &>()));

    
    template<typename Rng>
    using range_difference_type_t [[deprecated("range_difference_type_t is deprecated. Use the range_difference_t instead.")]] =
#line 82 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"
        iter_difference_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_value_type_t [[deprecated("range_value_type_t is deprecated. Use the range_value_t instead.")]] =
#line 87 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"
        iter_value_t<iterator_t<Rng>>;

    template<typename Rng>
    using range_category_t [[deprecated("range_category_t is deprecated. Use the range concepts instead.")]] =
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"
        meta::_t<detail::iterator_category<iterator_t<Rng>>>;

    template<typename Rng>
    using range_size_type_t [[deprecated("range_size_type_t is deprecated. Use range_size_t instead.")]] =
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"
        detail::iter_size_t<iterator_t<Rng>>;
    

    template<typename Rng>
    using range_common_iterator_t = common_iterator_t<iterator_t<Rng>, sentinel_t<Rng>>;

    
    namespace detail
    {
        template<typename Rng>
        using range_cpp17_iterator_t = cpp17_iterator_t<iterator_t<Rng>, sentinel_t<Rng>>;

        std::integral_constant<cardinality, finite> test_cardinality(void *);
        template<cardinality Card>
        std::integral_constant<cardinality, Card> test_cardinality(basic_view<Card> *);
        template<typename T, std::size_t N>
        std::integral_constant<cardinality, static_cast<cardinality>(N)> test_cardinality(
            T (*)[N]);
        template<typename T, std::size_t N>
        std::integral_constant<cardinality, static_cast<cardinality>(N)> test_cardinality(
            std::array<T, N> *);
    } 
    

    
    template<typename Rng, typename Void >
    struct range_cardinality
      : meta::conditional_t<std::is_same_v<Rng, uncvref_t<Rng>>,
                          decltype(detail::test_cardinality(
                              static_cast<uncvref_t<Rng> *>(nullptr))),
                          range_cardinality<uncvref_t<Rng>>>
    {};

    
    namespace cpp20
    {
        using ranges::range_difference_t;
        using ranges::range_reference_t;
        using ranges::range_rvalue_reference_t;
        using ranges::range_value_t;
    } 
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"

#line 143 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/traits.hpp"
#pragma external_header(pop)
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

namespace ranges
{
    
    

    
    
    

    
    
    
    template<typename T>
    concept _range_requires_ = requires(T & t) { ranges::begin(t), ranges::end(t); };
#line 66 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
    
    
    template<typename T>
    concept range =
        ranges::_range_requires_<T>;

    
    
    template<typename T>
    concept borrowed_range =
        range<T> && detail::_borrowed_range<T>;

    template <typename R>
    [[deprecated("Please use ranges::borrowed_range instead.")]]
    inline constexpr bool safe_range = borrowed_range<R>;

    
    
     template<typename T, typename V > concept output_range_concept_ = output_iterator<iterator_t<T>, V>;
#line 88 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
    
    
    template<typename T, typename V>
    concept output_range =
        range<T> && ranges::output_range_concept_<T, V>;

    
    
     template<typename T > concept input_range_concept_ = input_iterator<iterator_t<T>>;
#line 100 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
    
    
    template<typename T>
    concept input_range =
        range<T> && ranges::input_range_concept_<T>;

    
    
     template<typename T > concept forward_range_concept_ = forward_iterator<iterator_t<T>>;
#line 112 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
    
    
    template<typename T>
    concept forward_range =
        input_range<T> && ranges::forward_range_concept_<T>;

    
    
     template<typename T > concept bidirectional_range_concept_ = bidirectional_iterator<iterator_t<T>>;
#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
    
    
    template<typename T>
    concept bidirectional_range =
        forward_range<T> && ranges::bidirectional_range_concept_<T>;

    
    
     template<typename T > concept random_access_range_concept_ = random_access_iterator<iterator_t<T>>;
#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

    
    
    template<typename T>
    concept random_access_range =
        bidirectional_range<T> && ranges::random_access_range_concept_<T>;
    

    
    namespace detail
    {
        template<typename Rng>
        using data_t = decltype(ranges::data(std::declval<Rng &>()));

        template<typename Rng>
        using element_t = meta::_t<std::remove_pointer<data_t<Rng>>>;
    } 
      

    
    
    
     template<typename T > concept contiguous_range_concept_ = contiguous_iterator<iterator_t<T>> && same_as<detail::data_t<T>, std::add_pointer_t<iter_reference_t<iterator_t<T>>>>;
#line 163 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

    
    
    template<typename T>
    concept contiguous_range =
        random_access_range<T> && ranges::contiguous_range_concept_<T>;

    
    
     template<typename T > concept common_range_concept_ = same_as<iterator_t<T>, sentinel_t<T>>;
#line 176 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

    
    
    template<typename T>
    concept common_range =
        range<T> && ranges::common_range_concept_<T>;

    
    
    
    template<typename T>
    concept bounded_range =
        common_range<T>;
    

    
    
    template<typename T>
    concept sized_range_requires_ = requires(T & t) { ranges::size(t); };
#line 199 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
    
    
     template<typename T > concept sized_range_concept_ = detail::integer_like_<range_size_t<T>>;
#line 204 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

    
    
    template<typename T>
    concept sized_range =
        range<T> &&
        !disable_sized_range<uncvref_t<T>> &&
        ranges::sized_range_requires_<T> &&
        ranges::sized_range_concept_<T>;
    

    
    namespace ext
    {
        template<typename T>
        struct enable_view
          : std::is_base_of<view_base, T>
        {};
    } 
    

    
    template<typename T>
    inline constexpr bool enable_view =
        ext::enable_view<T>::value;


    template<typename Char, typename Traits>
    inline constexpr bool enable_view<std::basic_string_view<Char, Traits>> =
        true;
#line 235 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"




    template<typename T, std::size_t N>
    inline constexpr bool enable_view<std::span<T, N>> = N + 1 < 2;
#line 243 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

    
    
    

    
    
    
    template<typename T>
    concept view_ =
        range<T> &&
        semiregular<T> &&
        enable_view<T>;

    
    
    template<typename T>
    concept viewable_range =
        range<T> &&
        (borrowed_range<T> || view_<uncvref_t<T>>);
    

    
    
    struct range_tag
    {};

    struct input_range_tag : range_tag
    {};
    struct forward_range_tag : input_range_tag
    {};
    struct bidirectional_range_tag : forward_range_tag
    {};
    struct random_access_range_tag : bidirectional_range_tag
    {};
    struct contiguous_range_tag : random_access_range_tag
    {};

    template<typename Rng>
    using range_tag_of =                          
        std::enable_if_t<                         
            range<Rng>,                           
            meta::conditional_t<                    
                contiguous_range<Rng>,            
                contiguous_range_tag,             
                meta::conditional_t<                
                    random_access_range<Rng>,     
                    random_access_range_tag,      
                    meta::conditional_t<            
                        bidirectional_range<Rng>, 
                        bidirectional_range_tag,  
                        meta::conditional_t<        
                            forward_range<Rng>,   
                            forward_range_tag,    
                            meta::conditional_t<    
                                input_range<Rng>, 
                                input_range_tag,  
                                range_tag>>>>>>;

    
    
    struct common_range_tag : range_tag
    {};

    template<typename Rng>
    using common_range_tag_of = 
        std::enable_if_t<       
            range<Rng>,         
            meta::conditional_t<common_range<Rng>, common_range_tag, range_tag>>;

    
    
    struct sized_range_tag : range_tag
    {};

    template<typename Rng>
    using sized_range_tag_of = 
        std::enable_if_t<      
            range<Rng>,        
            meta::conditional_t<sized_range<Rng>, sized_range_tag, range_tag>>;

    
    namespace view_detail_
    {
        
        
        
        template<typename T>
        concept view =
            ranges::view_<T>;
        
    } 
    

    namespace cpp20
    {
        using ranges::borrowed_range;
        using ranges::bidirectional_range;
        using ranges::common_range;
        using ranges::contiguous_range;
        using ranges::enable_view;
        using ranges::forward_range;
        using ranges::input_range;
        using ranges::output_range;
        using ranges::random_access_range;
        using ranges::range;
        using ranges::sized_range;
        using ranges::viewable_range;
        using ranges::view_detail_::view;
        using ranges::view_base;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 358 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"

#line 360 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/concepts.hpp"
#pragma external_header(pop)
#line 24 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename T>
        struct movable_input_iterator
        {
            using iterator_category = std::input_iterator_tag;
            using value_type = T;
            using difference_type = std::ptrdiff_t;
            using pointer = T *;
            using reference = T &&;

            movable_input_iterator() = default;
            movable_input_iterator & operator++();
            movable_input_iterator operator++(int);
            bool operator==(movable_input_iterator const &) const;
            bool operator!=(movable_input_iterator const &) const;
            T && operator*() const;
        };
    } 
      

    
    

    
    
    
    
    template<typename T>
    concept semi_container =
        forward_range<T> && default_constructible<uncvref_t<T>> &&
        movable<uncvref_t<T>> &&
        !view_<T>;

    
    
    
     template<typename T > concept container_concept_ = constructible_from< uncvref_t<T>, detail::movable_input_iterator<range_value_t<T>>, detail::movable_input_iterator<range_value_t<T>>>;
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"

    
    
    template<typename T>
    concept container =
        semi_container<T> &&
        ranges::container_concept_<T>;

    
    
    template<typename C>
    concept reservable_requires_ = requires(C & c, C const & cc) { c.reserve(ranges::size(c)), cc.capacity(), cc.max_size(), concepts::requires_<same_as<decltype(cc.capacity()), decltype(ranges::size(c))>>, concepts::requires_<same_as<decltype(cc.max_size()), decltype(ranges::size(c))>>; };
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"

    
    
    template<typename C>
    concept reservable =
        container<C> && sized_range<C> && ranges::reservable_requires_<C>;

    
    
    template<typename C, typename I>
    concept reservable_with_assign_requires_ = requires(C & c, I i) { c.assign(i, i); };
#line 112 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
    
    
    template<typename C, typename I>
    concept reservable_with_assign =
        reservable<C> && 
        input_iterator<I> && 
        ranges::reservable_with_assign_requires_<C, I>;

    
    
    template<typename C>
    concept random_access_reservable =
        reservable<C> && random_access_range<C>;
    

    
    namespace detail
    {
         template<typename T > requires container<T>
#line 132 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
        std::true_type is_lvalue_container_like(T &) noexcept
        {
            return {};
        }

         template<typename T > requires container<T>
#line 139 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
        meta::not_<std::is_rvalue_reference<T>> 
        is_lvalue_container_like(reference_wrapper<T>) noexcept
        {
            return {};
        }

         template<typename T > requires container<T>
#line 147 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
        std::true_type is_lvalue_container_like(std::reference_wrapper<T>) noexcept
        {
            return {};
        }

         template<typename T > requires container<T>
#line 154 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
        std::true_type is_lvalue_container_like(ref_view<T>) noexcept
        {
            return {};
        }

        template<typename T>
        using is_lvalue_container_like_t =
            decltype(detail::is_lvalue_container_like(std::declval<T>()));

    } 
      

    
    
    
     template<typename T > concept lvalue_container_like_concept_ = implicitly_convertible_to<detail::is_lvalue_container_like_t<T>, std::true_type>;
#line 173 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
    
    
    template<typename T>
    concept lvalue_container_like =
        forward_range<T> &&
        ranges::lvalue_container_like_concept_<T>;
    
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"

#line 186 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/action/concepts.hpp"
#pragma external_header(pop)
#line 24 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"



















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"

namespace ranges
{
    
    
    template<typename Second, typename First>
    struct composed
    {
    private:
        
        First first_;
        
        Second second_;

        
        template<typename A, typename B, typename... Ts>
        static constexpr auto 
        do_ (A &&a, B &&b, std::false_type, Ts &&... ts) noexcept(noexcept(invoke((B &&) b, invoke((A &&) a, (Ts &&) ts...)))) -> decltype(invoke((B &&) b, invoke((A &&) a, (Ts &&) ts...))) { return (invoke((B &&) b, invoke((A &&) a, (Ts &&) ts...))); }
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
        template<typename A, typename B, typename... Ts>
        static constexpr auto do_ (A &&a, B &&b, std::true_type, Ts &&... ts) noexcept(noexcept((invoke((A &&) a, (Ts &&) ts...), invoke((B &&) b)))) -> decltype((invoke((A &&) a, (Ts &&) ts...), invoke((B &&) b))) { return ((invoke((A &&) a, (Ts &&) ts...), invoke((B &&) b))); }
#line 52 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
    public:
        composed() = default;
        
        constexpr composed(Second second, First first)
          : first_(std::move(first))
          , second_(std::move(second))
        {}
        
        template<typename... Ts>
        constexpr auto operator() (Ts &&... ts)  & noexcept(noexcept(composed::do_(first_, second_, std::is_void<invoke_result_t<First &, Ts...>>{}, (Ts &&) ts...))) -> decltype(composed::do_(first_, second_, std::is_void<invoke_result_t<First &, Ts...>>{}, (Ts &&) ts...)) { return (composed::do_(first_, second_, std::is_void<invoke_result_t<First &, Ts...>>{}, (Ts &&) ts...)); }
#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
        template<typename... Ts>
        constexpr auto operator() (Ts &&... ts) const & noexcept(noexcept(composed::do_((First const &)first_, (Second const &)second_, std::is_void<invoke_result_t<First const &, Ts...>>{}, (Ts &&) ts...))) -> decltype(composed::do_((First const &)first_, (Second const &)second_, std::is_void<invoke_result_t<First const &, Ts...>>{}, (Ts &&) ts...)) { return (composed::do_((First const &)first_, (Second const &)second_, std::is_void<invoke_result_t<First const &, Ts...>>{}, (Ts &&) ts...)); }
#line 76 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
        template<typename... Ts>
        constexpr auto operator() (Ts &&... ts)  && noexcept(noexcept(composed::do_((First &&)first_, (Second &&)second_, std::is_void<invoke_result_t<First &&, Ts...>>{}, (Ts &&) ts...))) -> decltype(composed::do_((First &&)first_, (Second &&)second_, std::is_void<invoke_result_t<First &&, Ts...>>{}, (Ts &&) ts...)) { return (composed::do_((First &&)first_, (Second &&)second_, std::is_void<invoke_result_t<First &&, Ts...>>{}, (Ts &&) ts...)); }
#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
        
    };

    struct compose_fn
    {
        template<typename Second, typename First>
        constexpr composed<Second, First> operator()(Second second, First first) const
        {
            return {std::move(second), std::move(first)};
        }
    };

    
    
    inline constexpr compose_fn compose{};
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"

#line 105 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/compose.hpp"
#pragma external_header(pop)
#line 21 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 25 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"

namespace ranges
{
    
    

    struct pipeable_base;

    template<typename T>
    inline constexpr bool is_pipeable_v = __is_base_of(pipeable_base, T);

    template<typename T>
    inline constexpr bool is_pipeable_v<T &> = __is_base_of(pipeable_base, T);
#line 39 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
    template<typename T>
    inline constexpr bool is_pipeable_v<T &&> = __is_base_of(pipeable_base, T);
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
    template<typename T>
    using is_pipeable = meta::bool_<is_pipeable_v<T>>;

    struct make_pipeable_fn
    {
        template<typename Fun, typename PipeableBase = pipeable_base>
        constexpr auto operator()(Fun fun) const
        {
            struct local
              : Fun
              , PipeableBase
            {
                constexpr explicit local(Fun && f)
                  : Fun(static_cast<Fun &&>(f))
                {}
            };
            return local{static_cast<Fun &&>(fun)};
        }
    };

    
    
    inline constexpr make_pipeable_fn make_pipeable{};

    struct pipeable_access
    {
        template<typename Pipeable>
        struct impl : Pipeable
        {
            using Pipeable::pipe;
        };
    };

    struct pipeable_base
    {
    private:
        friend pipeable_access;

        
         template<typename Arg, typename Pipe > requires (!is_pipeable_v<Arg>) && is_pipeable_v<Pipe> && invocable<Pipe, Arg> 
#line 84 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
        friend constexpr auto operator|(Arg &&arg, Pipe pipe) 
        {
            return static_cast<Pipe &&>(pipe)(static_cast<Arg &&>(arg));
        }

        
         template<typename Pipe0, typename Pipe1 > requires is_pipeable_v<Pipe0> && is_pipeable_v<Pipe1> 
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
        friend constexpr auto operator|(Pipe0 pipe0, Pipe1 pipe1) 
        {
            return make_pipeable(compose(detail::move(pipe1), detail::move(pipe0)));
        }

        template<typename Arg, typename Pipe>
        friend auto operator|=(Arg & arg, Pipe pipe) 
            -> ::concepts::return_t< Arg &, std::enable_if_t<( (is_pipeable_v<Pipe>) && (!is_pipeable_v<Arg>) && invocable<Pipe, Arg &> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 102 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
        {
            static_cast<Pipe &&>(pipe)(arg);
            return arg;
        }

        
        
        
        template<typename Arg, typename Pipe>
        static constexpr auto pipe (Arg && arg, Pipe p) noexcept(noexcept(static_cast<Pipe &&>(p)(static_cast<Arg &&>(arg)))) -> decltype(static_cast<Pipe &&>(p)(static_cast<Arg &&>(arg))) { return (static_cast<Pipe &&>(p)(static_cast<Arg &&>(arg))); }
#line 115 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
        
    };

    template<typename>
    using pipeable [[deprecated("Please use pipeable_base instead")]] = pipeable_base;

    

    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 127 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"

#line 129 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/pipeable.hpp"
#pragma external_header(pop)
#line 25 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"




































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 38 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"

namespace ranges
{
    template<std::size_t I>
    struct emplaced_index_t;

    template<std::size_t I>
    struct emplaced_index_t : meta::size_t<I>
    {};







#line 55 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
    template<std::size_t I>
    inline constexpr emplaced_index_t<I> emplaced_index{};
#line 58 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"

    struct bad_variant_access : std::logic_error
    {
        explicit bad_variant_access(std::string const & what_arg)
          : std::logic_error(what_arg)
        {}
        explicit bad_variant_access(char const * what_arg)
          : std::logic_error(what_arg)
        {}
    };

    template<typename T, std::size_t Index>
    struct indexed_element
    {
    private:
        std::add_pointer_t<T> t_;

    public:
        constexpr explicit indexed_element(T & t) noexcept
          : t_(std::addressof(t))
        {}
        constexpr T & get() const noexcept
        {
            return *t_;
        }
    };
    template<typename T, std::size_t Index>
    struct indexed_element<T &&, Index>
    {
    private:
        T * t_;

    public:
        constexpr explicit indexed_element(T && t) noexcept
          : t_(std::addressof(t))
        {}
        constexpr T && get() const noexcept
        {
            return static_cast<T &&>(*t_);
        }
    };
    template<std::size_t Index>
    struct indexed_element<void, Index>
    {
        void get() const noexcept
        {}
    };

    
    namespace detail
    {
        struct indexed_element_fn;

         template<typename I, typename S, typename O > requires (!sized_sentinel_for<S, I>) 
#line 113 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        O uninitialized_copy(I first, S last, O out)
        {
            for(; first != last; ++first, ++out)
                ::new((void *)std::addressof(*out)) iter_value_t<O>(*first);
            return out;
        }

         template<typename I, typename S, typename O > requires sized_sentinel_for<S, I>
#line 122 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        O uninitialized_copy(I first, S last, O out)
        {
            return std::uninitialized_copy_n(first, (last - first), out);
        }

        template<typename I, typename O>
        O uninitialized_copy(I first, I last, O out)
        {
            return std::uninitialized_copy(first, last, out);
        }

        template<typename T, typename Index>
        struct indexed_datum
        {
        private:
            template<typename, typename>
            friend struct indexed_datum;
            T datum_;

        public:
            
            constexpr indexed_datum () noexcept(std::is_nothrow_default_constructible<T>::value) requires default_constructible<T>
#line 146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
              : datum_{}
            {}
             template<typename... Ts > requires constructible_from<T, Ts...> && (sizeof...(Ts) != 0) 
#line 150 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
            constexpr indexed_datum(Ts &&... ts) noexcept(
                    std::is_nothrow_constructible<T, Ts...>::value)
              : datum_(static_cast<Ts &&>(ts)...)
            {}
             template<typename U > requires (!same_as<T, U>) && convertible_to<U, T>
#line 156 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
            constexpr indexed_datum(indexed_datum<U, Index> that) 
                noexcept(std::is_nothrow_constructible<T, U>::value) 
              : datum_(std::move(that.datum_))
            {}
            constexpr auto ref() noexcept
            {
                return indexed_element<T, Index::value>{datum_};
            }
            constexpr auto ref() const noexcept
            {
                return indexed_element<T const, Index::value>{datum_};
            }
            constexpr T & get() noexcept
            {
                return datum_;
            }
            constexpr T const & get() const noexcept
            {
                return datum_;
            }
        };

        template<typename T, std::size_t N, typename Index>
        struct indexed_datum<T[N], Index>;

        template<typename T, typename Index>
        struct indexed_datum<T &, Index>
        {
        private:
            template<typename, typename>
            friend struct indexed_datum;
            T * t_;

        public:
            constexpr indexed_datum(T & t) noexcept
              : t_(std::addressof(t))
            {}
            constexpr T & get() const noexcept
            {
                return *t_;
            }
            constexpr auto ref() const noexcept
            {
                return indexed_element<T &, Index::value>{*t_};
            }
        };
        template<typename T, typename Index>
        struct indexed_datum<T &&, Index>
        {
        private:
            template<typename, typename>
            friend struct indexed_datum;
            T * t_;

        public:
            constexpr indexed_datum(T && t) noexcept
              : t_(std::addressof(t))
            {}
            constexpr T && get() const noexcept
            {
                return static_cast<T &&>(*t_);
            }
            constexpr auto ref() const noexcept
            {
                return indexed_element<T &&, Index::value>{static_cast<T &&>(*t_)};
            }
        };
        template<typename Index>
        struct indexed_datum<void, Index>
        {
            void get() const noexcept
            {}
            constexpr indexed_element<void, Index::value> ref() const noexcept
            {
                return {};
            }
        };

        template<std::size_t Index, typename... Ts>
        using variant_datum_t =
            detail::indexed_datum<meta::at_c<meta::list<Ts...>, Index>,
                                  meta::size_t<Index>>;

        using variant_nil = indexed_datum<void, meta::npos>;

        template<typename Ts,
                 bool Trivial = meta::apply<
                     meta::quote<meta::and_>,
                     meta::transform<Ts, meta::quote<std::is_trivially_destructible>>>::
                     type::value>
        struct variant_data_
        {
            using type = indexed_datum<void, meta::npos>;
        };

        template<typename T, typename... Ts>
        struct variant_data_<meta::list<T, Ts...>, true>
        {
            struct type
            {
                using head_t = T;
                using tail_t = meta::_t<variant_data_<meta::list<Ts...>>>;
                union
                {
                    head_t head;
                    tail_t tail;
                };

                type() noexcept
                {}
                template<typename... Args>
                constexpr type(meta::size_t<0>, Args &&... args) noexcept(
                    std::is_nothrow_constructible<head_t, Args...>::value)
                  : head{((Args &&) args)...}
                {}
                template<std::size_t N, typename... Args>
                constexpr type(meta::size_t<N>, Args &&... args) noexcept(
                    std::is_nothrow_constructible<tail_t, meta::size_t<N - 1>,
                                                  Args...>::value)
                  : tail{meta::size_t<N - 1>{}, ((Args &&) args)...}
                {}
            };
        };

        template<typename T, typename... Ts>
        struct variant_data_<meta::list<T, Ts...>, false>
        {
            struct type
            {
                using head_t = T;
                using tail_t = meta::_t<variant_data_<meta::list<Ts...>>>;
                union
                {
                    head_t head;
                    tail_t tail;
                };

                type() noexcept
                {}
                ~type()
                {}
                template<typename... Args>
                constexpr type(meta::size_t<0>, Args &&... args) noexcept(
                    std::is_nothrow_constructible<head_t, Args...>::value)
                  : head{((Args &&) args)...}
                {}
                template<std::size_t N, typename... Args>
                constexpr type(meta::size_t<N>, Args &&... args) noexcept(
                    std::is_nothrow_constructible<tail_t, meta::size_t<N - 1>,
                                                  Args...>::value)
                  : tail{meta::size_t<N - 1>{}, ((Args &&) args)...}
                {}
            };
        };

        template<typename... Ts>
        using variant_data = meta::_t<variant_data_<meta::transform<
            meta::list<Ts...>, meta::as_list<meta::make_index_sequence<sizeof...(Ts)>>,
            meta::quote<indexed_datum>>>>;

        inline std::size_t variant_move_copy_(std::size_t, variant_nil, variant_nil)
        {
            return 0;
        }
        template<typename Data0, typename Data1>
        std::size_t variant_move_copy_(std::size_t n, Data0 & self, Data1 && that)
        {
            using Head = typename Data0::head_t;
            return 0 == n
                       ? ((void)::new((void *)&self.head) Head(((Data1 &&) that).head), 0)
                       : variant_move_copy_(n - 1, self.tail, ((Data1 &&) that).tail) + 1;
        }
        constexpr bool variant_equal_(std::size_t, variant_nil, variant_nil)
        {
            return true;
        }
        template<typename Data0, typename Data1>
        constexpr bool variant_equal_(std::size_t n, Data0 const & self,
                                      Data1 const & that)
        {
            return n == 0 ? self.head.get() == that.head.get()
                          : variant_equal_(n - 1, self.tail, that.tail);
        }
        template<typename Fun, typename Proj = indexed_element_fn>
        constexpr int variant_visit_(std::size_t, variant_nil, Fun, Proj = {})
        {
            return (static_cast<void>((false) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp", 342, "assertion failed: " "false")), 0);
        }
        template<typename Data, typename Fun, typename Proj = indexed_element_fn>
        constexpr int variant_visit_(std::size_t n, Data & self, Fun fun, Proj proj = {})
        {
            return 0 == n ? ((void)invoke(fun, invoke(proj, self.head)), 0)
                          : detail::variant_visit_(
                                n - 1, self.tail, detail::move(fun), detail::move(proj));
        }

        struct get_datum_fn
        {
            template<typename T>
            decltype(auto) operator()(T && t) const noexcept
            {
                return t.get();
            }
        };

        struct indexed_element_fn
        {
            template<typename T>
            decltype(auto) operator()(T && t) const noexcept
            {
                return t.ref();
            }
        };

        struct empty_variant_tag
        {};

        struct variant_core_access
        {
            template<typename... Ts>
            static constexpr variant_data<Ts...> & data(variant<Ts...> & var) noexcept
            {
                return var.data_();
            }
            template<typename... Ts>
            static constexpr variant_data<Ts...> const & data(
                variant<Ts...> const & var) noexcept
            {
                return var.data_();
            }
            template<typename... Ts>
            static constexpr variant_data<Ts...> && data(variant<Ts...> && var) noexcept
            {
                return detail::move(var.data_());
            }
            template<typename... Ts>
            static variant<Ts...> make_empty(meta::id<variant<Ts...>> = {}) noexcept
            {
                return variant<Ts...>{empty_variant_tag{}};
            }
        };

        struct delete_fn
        {
            template<typename T>
            void operator()(T const & t) const noexcept
            {
                t.~T();
            }
        };

        template<std::size_t N, typename... Ts>
        struct construct_fn
        {
            std::tuple<Ts...> args_;

            template<typename U, std::size_t... Is>
            void construct_(U & u, meta::index_sequence<Is...>) noexcept(
                std::is_nothrow_constructible<U, Ts...>::value)
            {
                ::new((void *)std::addressof(u))
                    U(static_cast<Ts &&>(std::get<Is>(args_))...);
            }

            construct_fn(Ts &&... ts) noexcept(
                std::is_nothrow_constructible<std::tuple<Ts...>, Ts...>::value)
              : args_{static_cast<Ts &&>(ts)...}
            {}
            template<typename U, std::size_t M>
            [[noreturn]] meta::if_c<N != M> operator()(
                indexed_datum<U, meta::size_t<M>> &) noexcept
            {
                static_cast<void>((false) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp", 428, "assertion failed: " "false"));
            }
            template<typename U>
            meta::if_<std::is_object<U>> operator()(
                indexed_datum<U, meta::size_t<N>> &
                    u) noexcept(std::is_nothrow_constructible<U, Ts...>::value)
            {
                this->construct_(u.get(), meta::make_index_sequence<sizeof...(Ts)>{});
            }
            template<typename U>
            meta::if_<meta::not_<std::is_object<U>>> operator()(
                indexed_datum<U, meta::size_t<N>> &
                    u) noexcept(std::is_nothrow_constructible<detail::decay_t<U>,
                                                              Ts...>::value)
            {
                this->construct_(u, meta::make_index_sequence<sizeof...(Ts)>{});
            }
        };

        template<typename T, std::size_t N>
        struct get_fn
        {
            T ** t_;

            template<typename U, std::size_t M>
            [[noreturn]] meta::if_c<M != N> operator()(indexed_element<U, M>) const
            {
                throw bad_variant_access("bad variant access");
            }
            template<typename U>
            void operator()(indexed_element<U, N> t) const noexcept
            {
                *t_ = std::addressof(t.get());
            }
            template<typename U>
            void operator()(indexed_element<U &&, N> t) const noexcept
            {
                U && u = t.get();
                *t_ = std::addressof(u);
            }
            void operator()(indexed_element<void, N>) const noexcept
            {}
        };

        template<typename Variant, std::size_t N>
        struct emplace_fn
        {
            Variant * var_;
            
            template<typename...Ts>
            auto operator() (Ts &&...ts) const noexcept(noexcept(var_->template emplace<N>(static_cast<Ts &&>(ts)...))) -> decltype(var_->template emplace<N>(static_cast<Ts &&>(ts)...)) { return (var_->template emplace<N>(static_cast<Ts &&>(ts)...)); }
#line 482 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
            
        };

        template<typename Fun, typename Variant>
        struct variant_visitor
        {
            Fun fun_;
            Variant * var_;

            
            template<typename U, std::size_t N>
            auto operator() (indexed_element<U, N> u) noexcept(noexcept(compose(emplace_fn<Variant, N>{var_}, fun_)(u))) -> decltype(compose(emplace_fn<Variant, N>{var_}, fun_)(u)) { return (compose(emplace_fn<Variant, N>{var_}, fun_)(u)); }
#line 497 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
            
        };

        template<typename Variant, typename Fun>
        variant_visitor<Fun, Variant> make_variant_visitor(
            Variant & var,
            Fun fun) noexcept(std::is_nothrow_move_constructible<Fun>::value)
        {
            return {detail::move(fun), &var};
        }

        template<typename To, typename From>
        struct unique_visitor;

        template<typename... To, typename... From>
        struct unique_visitor<variant<To...>, variant<From...>>
        {
            variant<To...> * var_;

            template<typename T, std::size_t N>
            void operator()(indexed_element<T, N> t) const
            {
                using E = meta::at_c<meta::list<From...>, N>;
                static_assert(std::is_same_v<T const, E const>,
                              "Is indexed_element broken?");
                using F = meta::find<meta::list<To...>, E>;
                static constexpr std::size_t M = sizeof...(To) - F::size();
                compose(emplace_fn<variant<To...>, M>{var_}, get_datum_fn{})(t);
            }
        };

        template<typename T>
        constexpr T & variant_deref_(T * t) noexcept
        {
            return *t;
        }
        inline void variant_deref_(void const volatile *) noexcept
        {}

        template<typename Variant>
        struct variant_get
        {
            
            
            template<std::size_t N>
            friend meta::_t<
                std::add_lvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>
            get(Variant & var)
            {
                using elem_t = meta::_t<
                    std::remove_reference<meta::at_c<meta::as_list<Variant>, N>>>;
                elem_t * elem = nullptr;
                auto & data_var = detail::variant_core_access::data(var);
                detail::variant_visit_(
                    var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
                return detail::variant_deref_(elem);
            }
            template<std::size_t N>
            friend meta::_t<
                std::add_lvalue_reference<meta::at_c<meta::as_list<Variant>, N> const>>
            get(Variant const & var)
            {
                using elem_t = meta::_t<
                    std::remove_reference<meta::at_c<meta::as_list<Variant>, N> const>>;
                elem_t * elem = nullptr;
                auto & data_var = detail::variant_core_access::data(var);
                detail::variant_visit_(
                    var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
                return detail::variant_deref_(elem);
            }
            template<std::size_t N>
            friend meta::_t<
                std::add_rvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>
            get(Variant && var)
            {
                using elem_t = meta::_t<
                    std::remove_reference<meta::at_c<meta::as_list<Variant>, N>>>;
                elem_t * elem = nullptr;
                auto & data_var = detail::variant_core_access::data(var);
                detail::variant_visit_(
                    var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
                using res_t = meta::_t<
                    std::add_rvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>;
                return static_cast<res_t>(detail::variant_deref_(elem));
            }
        };

        template<typename Variant,
                 bool Trivial = std::is_trivially_destructible<meta::apply<
                     meta::quote<variant_data>, meta::as_list<Variant>>>::value>
        struct variant_base : variant_get<Variant>
        {
            ~variant_base()
            {
                static_cast<Variant *>(this)->clear_();
            }
        };
        template<typename... Ts>
        struct variant_base<variant<Ts...>, true> : variant_get<variant<Ts...>>
        {};

        template<typename Fun, typename Types, typename Indices, typename = void>
        struct variant_visit_results
        {};
        template<typename Fun, typename... Ts, std::size_t... Is>
        struct variant_visit_results<
            Fun, meta::list<Ts...>, meta::index_sequence<Is...>,
            meta::void_<invoke_result_t<Fun &, indexed_element<Ts, Is>>...>>
        {
            using type = variant<invoke_result_t<Fun &, indexed_element<Ts, Is>>...>;
        };
        template<typename Fun, typename... Ts>
        using variant_visit_results_t =
            meta::_t<variant_visit_results<Fun, meta::list<Ts...>,
                                           meta::make_index_sequence<sizeof...(Ts)>>>;
    } 
    

    
    
    template<typename... Ts>
    struct variant
      : private detail::variant_data<Ts...>
      , private detail::variant_base<variant<Ts...>>
    {
    private:
        friend detail::variant_core_access;
        template<typename...>
        friend struct variant;
        friend detail::variant_base<variant, false>;
        template<std::size_t Index>
        using datum_t = detail::variant_datum_t<Index, Ts...>;
        template<typename T>
        using add_const_t = meta::if_<std::is_void<T>, void, T const>;
        using unbox_fn = detail::get_datum_fn;

        detail::variant_data<Ts...> & data_() & noexcept
        {
            return *this;
        }
        detail::variant_data<Ts...> const & data_() const & noexcept
        {
            return *this;
        }
        detail::variant_data<Ts...> && data_() && noexcept
        {
            return static_cast<detail::variant_data<Ts...> &&>(*this);
        }

        std::size_t index_;

        void clear_() noexcept
        {
            if(valid())
            {
                detail::variant_visit_(index_, data_(), detail::delete_fn{}, identity{});
                index_ = (std::size_t)-1;
            }
        }
        template<typename That>
        void assign_(That && that)
        {
            if(that.valid())
                index_ = detail::variant_move_copy_(
                    that.index_, data_(), ((That &&) that).data_());
        }
        constexpr variant(detail::empty_variant_tag) noexcept
          : detail::variant_data<Ts...>{}
          , index_((std::size_t)-1)
        {}
         template<typename... Args > requires (sizeof...(Args) == sizeof...(Ts)) 
#line 669 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        static constexpr bool all_convertible_to(int) noexcept
        {
            return and_v<convertible_to<Args, Ts>...>;
        }
        template<typename... Args>
        static constexpr bool all_convertible_to(long) noexcept
        {
            return false;
        }

    public:
        
        constexpr variant () noexcept(std::is_nothrow_default_constructible<datum_t<0>>::value) requires default_constructible<datum_t<0>>
#line 684 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
          : variant{emplaced_index<0>}
        {}
         template<std::size_t N, typename... Args > requires constructible_from<datum_t<N>, Args...>
#line 688 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
            constexpr variant(emplaced_index_t<N>, Args &&... args) noexcept(
                std::is_nothrow_constructible<datum_t<N>, Args...>::value)
          : detail::variant_data<Ts...>{meta::size_t<N>{}, static_cast<Args &&>(args)...}
          , index_(N)
        {}
         template<std::size_t N, typename T, typename... Args > requires constructible_from<datum_t<N>, std::initializer_list<T> &, Args...>
#line 696 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
            constexpr variant(
                emplaced_index_t<N>, std::initializer_list<T> il,
                Args &&... args) noexcept(std::
                                              is_nothrow_constructible<
                                                  datum_t<N>, std::initializer_list<T> &,
                                                  Args...>::value)
          : detail::variant_data<Ts...>{meta::size_t<N>{},
                                        il,
                                        static_cast<Args &&>(args)...}
          , index_(N)
        {}
         template<std::size_t N > requires constructible_from<datum_t<N>, meta::nil_>
#line 709 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        constexpr variant(emplaced_index_t<N>, meta::nil_)
            noexcept(std::is_nothrow_constructible<datum_t<N>, meta::nil_>::value)
          : detail::variant_data<Ts...>{meta::size_t<N>{}, meta::nil_{}}
          , index_(N)
        {}
        variant(variant && that)
          : detail::variant_data<Ts...>{}
          , index_(detail::variant_move_copy_(that.index(), data_(),
                                              std::move(that.data_())))
        {}
        variant(variant const & that)
          : detail::variant_data<Ts...>{}
          , index_(detail::variant_move_copy_(that.index(), data_(), that.data_()))
        {}
         template<typename... Args > requires (!same_as<variant<Args...>, variant>) && (all_convertible_to<Args...>(0)) 
#line 726 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        variant(variant<Args...> that)
          : detail::variant_data<Ts...>{}
          , index_(detail::variant_move_copy_(that.index(), data_(),
                                              std::move(that.data_())))
        {}
        variant & operator=(variant && that)
        {
            
            this->clear_();
            this->assign_(detail::move(that));
            return *this;
        }
        variant & operator=(variant const & that)
        {
            
            this->clear_();
            this->assign_(that);
            return *this;
        }
         template<typename... Args > requires (!same_as<variant<Args...>, variant>) && (all_convertible_to<Args...>(0))
#line 748 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        variant & operator=(variant<Args...> that)
        {
            
            this->clear_();
            this->assign_(that);
            return *this;
        }
        static constexpr std::size_t size() noexcept
        {
            return sizeof...(Ts);
        }
         template<std::size_t N, typename... Args > requires constructible_from<datum_t<N>, Args...>
#line 761 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
        void emplace(Args &&... args)
        {
            this->clear_();
            detail::construct_fn<N, Args &&...> fn{static_cast<Args &&>(args)...};
            detail::variant_visit_(N, data_(), std::ref(fn), identity{});
            index_ = N;
        }
        constexpr bool valid() const noexcept
        {
            return index() != (std::size_t)-1;
        }
        constexpr std::size_t index() const noexcept
        {
            return index_;
        }
        template<typename Fun>
        detail::variant_visit_results_t<composed<Fun, unbox_fn>, Ts...> visit(Fun fun)
        {
            detail::variant_visit_results_t<composed<Fun, unbox_fn>, Ts...> res{
                detail::empty_variant_tag{}};
            detail::variant_visit_(index_,
                                   data_(),
                                   detail::make_variant_visitor(
                                       res, compose(detail::move(fun), unbox_fn{})));
            return res;
        }
        template<typename Fun>
        detail::variant_visit_results_t<composed<Fun, unbox_fn>, add_const_t<Ts>...>
        visit(Fun fun) const
        {
            detail::variant_visit_results_t<composed<Fun, unbox_fn>, add_const_t<Ts>...>
                res{detail::empty_variant_tag{}};
            detail::variant_visit_(index_,
                                   data_(),
                                   detail::make_variant_visitor(
                                       res, compose(detail::move(fun), unbox_fn{})));
            return res;
        }
        template<typename Fun>
        detail::variant_visit_results_t<Fun, Ts...> visit_i(Fun fun)
        {
            detail::variant_visit_results_t<Fun, Ts...> res{detail::empty_variant_tag{}};
            detail::variant_visit_(
                index_, data_(), detail::make_variant_visitor(res, detail::move(fun)));
            return res;
        }
        template<typename Fun>
        detail::variant_visit_results_t<Fun, add_const_t<Ts>...> visit_i(Fun fun) const
        {
            detail::variant_visit_results_t<Fun, add_const_t<Ts>...> res{
                detail::empty_variant_tag{}};
            detail::variant_visit_(
                index_, data_(), detail::make_variant_visitor(res, detail::move(fun)));
            return res;
        }
    };

     template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...>
#line 820 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
    bool operator==(variant<Ts...> const & lhs, variant<Us...> const & rhs)
    {
        return (!lhs.valid() && !rhs.valid()) ||
               (lhs.index() == rhs.index() &&
                detail::variant_equal_(lhs.index(),
                                       detail::variant_core_access::data(lhs),
                                       detail::variant_core_access::data(rhs)));
    }

     template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...>
#line 831 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
    bool operator!=(variant<Ts...> const & lhs, variant<Us...> const & rhs)
    {
        return !(lhs == rhs);
    }

    
    
     template<std::size_t N, typename... Ts, typename... Args > requires constructible_from<detail::variant_datum_t<N, Ts...>, Args...>
#line 840 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
    void emplace(variant<Ts...> & var, Args &&... args)
    {
        var.template emplace<N>(static_cast<Args &&>(args)...);
    }

    
    
    template<typename Var>
    struct variant_unique
    {};

    template<typename... Ts>
    struct variant_unique<variant<Ts...>>
    {
        using type = meta::apply<meta::quote<variant>, meta::unique<meta::list<Ts...>>>;
    };

    template<typename Var>
    using variant_unique_t = meta::_t<variant_unique<Var>>;

    
    
    template<typename... Ts>
    variant_unique_t<variant<Ts...>> unique_variant(variant<Ts...> const & var)
    {
        using From = variant<Ts...>;
        using To = variant_unique_t<From>;
        auto res = detail::variant_core_access::make_empty(meta::id<To>{});
        var.visit_i(detail::unique_visitor<To, From>{&res});
        static_cast<void>((res.valid()) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp", 869, "assertion failed: " "res.valid()"));
        return res;
    }
    
} 

__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))

namespace std
{
    template<typename... Ts>
    struct tuple_size<::ranges::variant<Ts...>> : tuple_size<tuple<Ts...>>
    {};

    template<size_t I, typename... Ts>
    struct tuple_element<I, ::ranges::variant<Ts...>> : tuple_element<I, tuple<Ts...>>
    {};
} 

__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 892 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"

#line 894 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/variant.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"



























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"

namespace ranges
{
    
    
    template<typename T,
             typename U = meta::if_<
                 std::is_lvalue_reference<T>,
                 std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
    U bind_forward(meta::_t<std::remove_reference<T>> & t) noexcept
    {
        return static_cast<U>(t);
    }

    template<typename T>
    T && bind_forward(meta::_t<std::remove_reference<T>> && t) noexcept
    {
        
        static_assert(!std::is_lvalue_reference<T>::value, "You didn't just do that!");
        return static_cast<T &&>(t);
    }

    template<typename T>
    struct bind_element
      : meta::if_c<std::is_same_v<detail::decay_t<T>, T>, meta::id<T>,
                   bind_element<detail::decay_t<T>>>
    {};

    template<typename T>
    struct bind_element<std::reference_wrapper<T>>
    {
        using type = T &;
    };

    template<typename T>
    struct bind_element<reference_wrapper<T>>
    {
        using type = typename reference_wrapper<T>::reference;
    };

    template<typename T>
    using bind_element_t = meta::_t<bind_element<T>>;

    template<typename Bind>
    struct protector
    {
    private:
        Bind bind_;

    public:
        protector() = default;
        protector(Bind b)
          : bind_(std::move(b))
        {}
        
        template<typename...Ts>
        auto operator() (Ts &&...ts) noexcept(noexcept(bind_(static_cast<Ts &&>(ts)...))) -> decltype(bind_(static_cast<Ts &&>(ts)...)) { return (bind_(static_cast<Ts &&>(ts)...)); }
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"
        
        template<typename...Ts>
        auto operator() (Ts &&...ts) const noexcept(noexcept(bind_(static_cast<Ts &&>(ts)...))) -> decltype(bind_(static_cast<Ts &&>(ts)...)) { return (bind_(static_cast<Ts &&>(ts)...)); }
#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"
        
    };

    struct protect_fn
    {
         template<typename F > requires std::is_bind_expression<uncvref_t<F>>::value 
#line 102 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"
        protector<uncvref_t<F>> operator()(F && f) const
        {
            return {static_cast<F &&>(f)};
        }
        
         template<typename F > requires (!std::is_bind_expression<uncvref_t<F>>::value) 
#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"
        F operator()(F && f) const
        {
            return static_cast<F &&>(f);
        }
    };

    
    
    
    
    inline constexpr protect_fn protect{};
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"

#line 126 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind.hpp"
#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"





























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"

namespace ranges
{
    
    
    template<typename Tup>
    using tuple_indices_t = meta::make_index_sequence<
        std::tuple_size<typename std::remove_reference<Tup>::type>::value>;

    struct tuple_apply_fn
    {
        
    private:
        template<typename Fun, typename Tup, std::size_t... Is>
        static constexpr auto 
        impl (Fun &&fun, Tup &&tup, meta::index_sequence<Is...>) noexcept(noexcept(invoke(static_cast<Fun &&>(fun), detail::adl_get<Is>(static_cast<Tup &&>(tup))...))) -> decltype(invoke(static_cast<Fun &&>(fun), detail::adl_get<Is>(static_cast<Tup &&>(tup))...)) { return (invoke(static_cast<Fun &&>(fun), detail::adl_get<Is>(static_cast<Tup &&>(tup))...)); }
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
    public:
        template<typename Fun, typename Tup>
        constexpr auto operator() (Fun &&fun, Tup &&tup) const noexcept(noexcept(tuple_apply_fn::impl(static_cast<Fun &&>(fun), static_cast<Tup &&>(tup), tuple_indices_t<Tup>{}))) -> decltype(tuple_apply_fn::impl(static_cast<Fun &&>(fun), static_cast<Tup &&>(tup), tuple_indices_t<Tup>{})) { return (tuple_apply_fn::impl(static_cast<Fun &&>(fun), static_cast<Tup &&>(tup), tuple_indices_t<Tup>{})); }
#line 59 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        
    };

    
    
    inline constexpr tuple_apply_fn tuple_apply{};

    struct tuple_transform_fn
    {
        
    private:
        template<typename Tup, typename Fun, std::size_t... Is>
        static constexpr auto 
        impl1 (Tup &&tup, Fun &fun, meta::index_sequence<Is...>) noexcept(noexcept(std::tuple< decltype(fun(detail::adl_get<Is>(static_cast<Tup &&>(tup))))...>{ fun(detail::adl_get<Is>(static_cast<Tup &&>( tup)))...})) -> decltype(std::tuple< decltype(fun(detail::adl_get<Is>(static_cast<Tup &&>(tup))))...>{ fun(detail::adl_get<Is>(static_cast<Tup &&>( tup)))...}) { return (std::tuple< decltype(fun(detail::adl_get<Is>(static_cast<Tup &&>(tup))))...>{ fun(detail::adl_get<Is>(static_cast<Tup &&>( tup)))...}); }
#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        template<typename Tup0, typename Tup1, typename Fun, std::size_t... Is>
        static constexpr auto impl2 (Tup0 &&tup0, Tup1 &&tup1, Fun &fun, meta::index_sequence<Is...>) noexcept(noexcept(std::tuple< decltype(fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)), detail::adl_get<Is>(static_cast<Tup1 &&>(tup1))))...>{ fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)), detail::adl_get<Is>(static_cast<Tup1 &&>(tup1)))...})) -> decltype(std::tuple< decltype(fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)), detail::adl_get<Is>(static_cast<Tup1 &&>(tup1))))...>{ fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)), detail::adl_get<Is>(static_cast<Tup1 &&>(tup1)))...}) { return (std::tuple< decltype(fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)), detail::adl_get<Is>(static_cast<Tup1 &&>(tup1))))...>{ fun(detail::adl_get<Is>(static_cast<Tup0 &&>(tup0)), detail::adl_get<Is>(static_cast<Tup1 &&>(tup1)))...}); }
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
    public:
        template<typename Tup, typename Fun>
        constexpr auto operator() (Tup &&tup, Fun fun) const noexcept(noexcept(tuple_transform_fn::impl1( static_cast<Tup &&>(tup), fun, tuple_indices_t<Tup>{}))) -> decltype(tuple_transform_fn::impl1( static_cast<Tup &&>(tup), fun, tuple_indices_t<Tup>{})) { return (tuple_transform_fn::impl1( static_cast<Tup &&>(tup), fun, tuple_indices_t<Tup>{})); }
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        template<typename Tup0, typename Tup1, typename Fun>
        constexpr auto operator() (Tup0 &&tup0, Tup1 &&tup1, Fun fun) const noexcept(noexcept(tuple_transform_fn::impl2(static_cast<Tup0 &&>(tup0), static_cast<Tup1 &&>(tup1), fun, tuple_indices_t<Tup0>{}))) -> decltype(tuple_transform_fn::impl2(static_cast<Tup0 &&>(tup0), static_cast<Tup1 &&>(tup1), fun, tuple_indices_t<Tup0>{})) { return (tuple_transform_fn::impl2(static_cast<Tup0 &&>(tup0), static_cast<Tup1 &&>(tup1), fun, tuple_indices_t<Tup0>{})); }
#line 104 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        
    };

    
    
    inline constexpr tuple_transform_fn tuple_transform{};

    struct tuple_foldl_fn
    {
    private:
        template<typename Tup, typename Val, typename Fun>
        static constexpr Val impl(Tup &&, Val val, Fun &)
        {
            return val;
        }
        
        template<std::size_t I0, std::size_t... Is, typename Tup, typename Val,
                 typename Fun, typename Impl = tuple_foldl_fn>
        static constexpr auto impl (Tup &&tup, Val val, Fun &fun) noexcept(noexcept(Impl::template impl<Is...>( static_cast<Tup &&>(tup), fun(std::move(val), detail::adl_get<I0>(static_cast<Tup &&>(tup))), fun))) -> decltype(Impl::template impl<Is...>( static_cast<Tup &&>(tup), fun(std::move(val), detail::adl_get<I0>(static_cast<Tup &&>(tup))), fun)) { return (Impl::template impl<Is...>( static_cast<Tup &&>(tup), fun(std::move(val), detail::adl_get<I0>(static_cast<Tup &&>(tup))), fun)); }
#line 129 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        template<typename Tup, typename Val, typename Fun, std::size_t... Is>
        static constexpr auto impl2 (Tup &&tup, Val val, Fun &fun, meta::index_sequence<Is...>) noexcept(noexcept(tuple_foldl_fn::impl<Is...>(static_cast<Tup &&>(tup), std::move(val), fun))) -> decltype(tuple_foldl_fn::impl<Is...>(static_cast<Tup &&>(tup), std::move(val), fun)) { return (tuple_foldl_fn::impl<Is...>(static_cast<Tup &&>(tup), std::move(val), fun)); }
#line 137 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
    public:
        template<typename Tup, typename Val, typename Fun>
        constexpr auto operator() (Tup &&tup, Val val, Fun fun) const noexcept(noexcept(tuple_foldl_fn::impl2(static_cast<Tup &&>(tup), std::move(val), fun, tuple_indices_t<Tup>{}))) -> decltype(tuple_foldl_fn::impl2(static_cast<Tup &&>(tup), std::move(val), fun, tuple_indices_t<Tup>{})) { return (tuple_foldl_fn::impl2(static_cast<Tup &&>(tup), std::move(val), fun, tuple_indices_t<Tup>{})); }
#line 146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        
    };

    
    
    inline constexpr tuple_foldl_fn tuple_foldl{};

    struct tuple_for_each_fn
    {
    private:
        template<typename Tup, typename Fun, std::size_t... Is>
        static constexpr void impl(Tup && tup, Fun & fun, meta::index_sequence<Is...>)
        {
            (void)std::initializer_list<int>{
                ((void)fun(detail::adl_get<Is>(static_cast<Tup &&>(tup))), 42)...};
        }

    public:
        template<typename Tup, typename Fun>
        constexpr Fun operator()(Tup && tup, Fun fun) const
        {
            return tuple_for_each_fn::impl(
                       static_cast<Tup &&>(tup), fun, tuple_indices_t<Tup>{}),
                   fun;
        }
    };

    
    
    inline constexpr tuple_for_each_fn tuple_for_each{};

    struct make_tuple_fn
    {
        
        template<typename... Ts>
        constexpr auto operator() (Ts &&... ts) const noexcept(noexcept(std::make_tuple(static_cast<Ts &&>(ts)...))) -> decltype(std::make_tuple(static_cast<Ts &&>(ts)...)) { return (std::make_tuple(static_cast<Ts &&>(ts)...)); }
#line 185 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
        
    };

    
    
    inline constexpr make_tuple_fn make_tuple{};
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 195 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"

#line 197 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/tuple_algorithm.hpp"
#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename... Us, typename Tup, std::size_t... Is>
        std::tuple<Us...> to_std_tuple(Tup && tup, meta::index_sequence<Is...>)
        {
            return std::tuple<Us...>{adl_get<Is>(static_cast<Tup &&>(tup))...};
        }


        template<std::size_t, typename...>
        struct args_;

        template<typename, typename>
        inline constexpr bool argstructible = false;
        template<std::size_t N, typename... Ts, typename... Us>
        inline constexpr bool argstructible<args_<N, Ts...>, args_<N, Us...>> =
            (__is_constructible(Ts, Us) && ...);

        template<typename, typename>
        inline constexpr bool argsignable = false;
        template<std::size_t N, typename... Ts, typename... Us>
        inline constexpr bool argsignable<args_<N, Ts...>, args_<N, Us...>> =
            (std::is_assignable_v<Ts &, Us> && ...);
#line 60 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"

        template<std::size_t N, typename... Ts>
        struct args_
        {
            template<typename... Us>
            args_(args_<N, Us...>, meta::if_c<

                                       argstructible<args_, args_<N, Us...>>



#line 72 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
                                       > * = nullptr)
            {}
            template<typename... Us>
            meta::if_c<

                argsignable<args_, args_<N, Us...>>,


#line 81 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
                args_ &>
            operator=(args_<N, Us...>)
            {
                return *this;
            }
        };
        template<typename... Ts>
        using args = args_<sizeof...(Ts), Ts...>;
        template<typename... Ts>
        using rargs = args_<sizeof...(Ts), Ts &...>;
    } 
    

    template<typename... Ts>
    struct common_tuple : _tuple_wrapper_::forward_tuple_interface<std::tuple<Ts...>>
    {
    private:
        template<typename That, std::size_t... Is>
        common_tuple(That && that, meta::index_sequence<Is...>)
          : common_tuple::forward_tuple_interface{
                detail::adl_get<Is>(static_cast<That &&>(that))...}
        {}
        struct element_assign_
        {
            template<typename T, typename U>
            int operator()(T & t, U && u) const
            {
                t = static_cast<U &&>(u);
                return 0;
            }
        };

    public:
        
        
        common_tuple () noexcept( meta::and_c<std::is_nothrow_default_constructible<Ts>::value...>::value) requires default_constructible<std::tuple<Ts...>>
#line 120 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
          : common_tuple::forward_tuple_interface{}
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::args<Us...>>
#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        explicit common_tuple(Us &&... us) 
            noexcept(meta::and_c<std::is_nothrow_constructible<Ts, Us>::value...>::value)
          : common_tuple::forward_tuple_interface{static_cast<Us &&>(us)...}
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::rargs<Us...>>
#line 130 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple(std::tuple<Us...> & that) 
            noexcept(
                meta::and_c<std::is_nothrow_constructible<Ts, Us &>::value...>::value) 
          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::rargs<Us const...>>
#line 137 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple(std::tuple<Us...> const & that) 
            noexcept(meta::and_c<
                     std::is_nothrow_constructible<Ts, Us const &>::value...>::value) 
          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::args<Us...>>
#line 144 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple(std::tuple<Us...> && that) 
            noexcept(
                meta::and_c<std::is_nothrow_constructible<Ts, Us>::value...>::value) 
          : common_tuple(std::move(that), meta::make_index_sequence<sizeof...(Ts)>{})
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::rargs<Us...>>
#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple(common_tuple<Us...> & that) 
            noexcept(
                meta::and_c<std::is_nothrow_constructible<Ts, Us &>::value...>::value) 
          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::rargs<Us const...>>
#line 158 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple(common_tuple<Us...> const & that) 
            noexcept(meta::and_c<
                     std::is_nothrow_constructible<Ts, Us const &>::value...>::value) 
          : common_tuple(that, meta::make_index_sequence<sizeof...(Ts)>{})
        {}
         template<typename... Us > requires constructible_from<detail::args<Ts...>, detail::args<Us...>>
#line 165 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple(common_tuple<Us...> && that) 
            noexcept(
                meta::and_c<std::is_nothrow_constructible<Ts, Us>::value...>::value) 
          : common_tuple(std::move(that), meta::make_index_sequence<sizeof...(Ts)>{})
        {}

        std::tuple<Ts...> & base() noexcept
        {
            return *this;
        }
        std::tuple<Ts...> const & base() const noexcept
        {
            return *this;
        }

        
         template<typename... Us > requires std::is_assignable<detail::args<Ts...> &, detail::rargs<Us...>>::value 
#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple & operator=(std::tuple<Us...> & that) noexcept(
            meta::and_c<std::is_nothrow_assignable<Ts &, Us &>::value...>::value)
        {
            (void)tuple_transform(base(), that, element_assign_{});
            return *this;
        }
         template<typename... Us > requires std::is_assignable<detail::args<Ts...> &, detail::rargs<Us const...>>::value 
#line 193 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple & operator=(std::tuple<Us...> const & that) noexcept(
            meta::and_c<std::is_nothrow_assignable<Ts &, Us const &>::value...>::value)
        {
            (void)tuple_transform(base(), that, element_assign_{});
            return *this;
        }
         template<typename... Us > requires std::is_assignable<detail::args<Ts...> &, detail::args<Us...>>::value 
#line 202 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple & operator=(std::tuple<Us...> && that) noexcept(
            meta::and_c<std::is_nothrow_assignable<Ts &, Us>::value...>::value)
        {
            (void)tuple_transform(base(), std::move(that), element_assign_{});
            return *this;
        }

         template<typename... Us > requires std::is_assignable<detail::args<Ts const...> &, detail::rargs<Us...>>::value
#line 212 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple const & operator=(std::tuple<Us...> & that) const noexcept(
            meta::and_c<std::is_nothrow_assignable<Ts const &, Us &>::value...>::value)
        {
            (void)tuple_transform(base(), that, element_assign_{});
            return *this;
        }
         template<typename... Us > requires std::is_assignable<detail::args<Ts const...> &, detail::rargs<Us const...>>::value
#line 221 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple const & operator=(std::tuple<Us...> const & that) const
            noexcept(meta::and_c<
                     std::is_nothrow_assignable<Ts const &, Us const &>::value...>::value)
        {
            (void)tuple_transform(base(), that, element_assign_{});
            return *this;
        }
         template<typename... Us > requires std::is_assignable<detail::args<Ts const...> &, detail::args<Us...>>::value
#line 231 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_tuple const & operator=(std::tuple<Us...> && that) const noexcept(
            meta::and_c<std::is_nothrow_assignable<Ts const &, Us &&>::value...>::value)
        {
            (void)tuple_transform(base(), std::move(that), element_assign_{});
            return *this;
        }

        
         template<typename... Us > requires constructible_from<detail::args<Us...>, detail::rargs<Ts...>>
#line 241 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        operator std::tuple<Us...>() & noexcept(
                meta::and_c<std::is_nothrow_constructible<Us, Ts &>::value...>::value)
        {
            return detail::to_std_tuple<Us...>(
                *this, meta::make_index_sequence<sizeof...(Ts)>{});
        }
         template<typename... Us > requires constructible_from<detail::args<Us...>, detail::rargs<Ts const...>>
#line 250 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        operator std::tuple<Us...>() const & noexcept(
            meta::and_c<std::is_nothrow_constructible<Us, Ts const &>::value...>::value)
        {
            return detail::to_std_tuple<Us...>(
                *this, meta::make_index_sequence<sizeof...(Ts)>{});
        }
         template<typename... Us > requires constructible_from<detail::args<Us...>, detail::args<Ts...>>
#line 258 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        operator std::tuple<Us...>() &&
            noexcept(meta::and_c<std::is_nothrow_constructible<Us, Ts>::value...>::value)
        {
            return detail::to_std_tuple<Us...>(
                std::move(*this), meta::make_index_sequence<sizeof...(Ts)>{});
        }
    };

    




















     template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...> bool operator ==(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() == b.base(); }  template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...> bool operator ==(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a == b.base(); }  template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...> bool operator ==(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) { return a.base() == b; }
     template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...> bool operator !=(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() != b.base(); }  template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...> bool operator !=(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a != b.base(); }  template<typename... Ts, typename... Us > requires and_v<equality_comparable_with<Ts, Us>...> bool operator !=(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) { return a.base() != b; }
     template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator <(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() < b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator <(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a < b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator <(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) { return a.base() < b; }
     template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator <=(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() <= b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator <=(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a <= b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator <=(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) { return a.base() <= b; }
     template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator >(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() > b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator >(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a > b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator >(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) { return a.base() > b; }
     template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator >=(common_tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a.base() >= b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator >=(std::tuple<Ts...> const & a, common_tuple<Us...> const & b) { return a >= b.base(); }  template<typename... Ts, typename... Us > requires and_v<totally_ordered_with<Ts, Us>...> bool operator >=(common_tuple<Ts...> const & a, std::tuple<Us...> const & b) { return a.base() >= b; }


    struct make_common_tuple_fn
    {
        template<typename... Args>
        common_tuple<bind_element_t<Args>...> operator()(Args &&... args) const noexcept(
            meta::and_c<std::is_nothrow_constructible<
                bind_element_t<Args>, unwrap_reference_t<Args>>::value...>::value)
        {
            return common_tuple<bind_element_t<Args>...>{
                unwrap_reference(static_cast<Args &&>(args))...};
        }
    };

    
    
    inline constexpr make_common_tuple_fn make_common_tuple{};

    template<typename F, typename S>
    struct common_pair : std::pair<F, S>
    {
    private:
        std::pair<F, S> const & base() const noexcept
        {
            return *this;
        }

    public:
        
        
        common_pair () noexcept(std::is_nothrow_default_constructible<F>::value && std::is_nothrow_default_constructible<S>::value) requires default_constructible<F> && default_constructible<S>
#line 327 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
          : std::pair<F, S>{}
        {}
         template<typename F2, typename S2 > requires constructible_from<F, F2> && constructible_from<S, S2>
#line 331 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair(F2 && f2, S2 && s2) 
            noexcept(std::is_nothrow_constructible<F, F2>::value &&
                     std::is_nothrow_constructible<S, S2>::value) 
          : std::pair<F, S>{static_cast<F2 &&>(f2), static_cast<S2 &&>(s2)}
        {}
         template<typename F2, typename S2 > requires constructible_from<F, F2 &> && constructible_from<S, S2 &>
#line 338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair(std::pair<F2, S2> & that) 
            noexcept(std::is_nothrow_constructible<F, F2 &>::value &&
                     std::is_nothrow_constructible<S, S2 &>::value) 
          : std::pair<F, S>{that.first, that.second}
        {}
         template<typename F2, typename S2 > requires constructible_from<F, F2 const &> && constructible_from<S, S2 const &>
#line 346 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair(std::pair<F2, S2> const & that) 
            noexcept(std::is_nothrow_constructible<F, F2 const &>::value &&
                     std::is_nothrow_constructible<S, S2 const &>::value) 
          : std::pair<F, S>{that.first, that.second}
        {}
         template<typename F2, typename S2 > requires constructible_from<F, F2> && constructible_from<S, S2>
#line 353 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair(std::pair<F2, S2> && that) 
            noexcept(std::is_nothrow_constructible<F, F2>::value &&
                     std::is_nothrow_constructible<S, S2>::value) 
          : std::pair<F, S>{std::forward<F2>(that.first), std::forward<S2>(that.second)}
        {}

        
         template<typename F2, typename S2 > requires constructible_from<F2, F &> && constructible_from<S2, S &>
#line 362 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        operator std::pair<F2, S2>() & 
            noexcept(std::is_nothrow_constructible<F2, F &>::value &&
                     std::is_nothrow_constructible<S2, S &>::value)
        {
            return {this->first, this->second};
        }
         template<typename F2, typename S2 > requires constructible_from<F2, F const &> && constructible_from<S2, S const &>
#line 371 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        operator std::pair<F2, S2>() const & 
            noexcept(std::is_nothrow_constructible<F2, F const &>::value &&
                     std::is_nothrow_constructible<S2, S const &>::value)
        {
            return {this->first, this->second};
        }
         template<typename F2, typename S2 > requires constructible_from<F2, F> && constructible_from<S2, S>
#line 379 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        operator std::pair<F2, S2>() &&
            noexcept(std::is_nothrow_constructible<F2, F>::value &&
                     std::is_nothrow_constructible<S2, S>::value)
        {
            return {std::forward<F>(this->first), std::forward<S>(this->second)};
        }

        
         template<typename F2, typename S2 > requires assignable_from<F &, F2 &> && assignable_from<S &, S2 &>
#line 389 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair & operator=(std::pair<F2, S2> & that) 
            noexcept(std::is_nothrow_assignable<F &, F2 &>::value &&
                     std::is_nothrow_assignable<S &, S2 &>::value)
        {
            this->first = that.first;
            this->second = that.second;
            return *this;
        }
         template<typename F2, typename S2 > requires assignable_from<F &, F2 const &> && assignable_from<S &, S2 const &>
#line 400 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair & operator=(std::pair<F2, S2> const & that) 
            noexcept(std::is_nothrow_assignable<F &, F2 const &>::value &&
                     std::is_nothrow_assignable<S &, S2 const &>::value)
        {
            this->first = that.first;
            this->second = that.second;
            return *this;
        }
         template<typename F2, typename S2 > requires assignable_from<F &, F2> && assignable_from<S &, S2>
#line 410 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair & operator=(std::pair<F2, S2> && that) 
            noexcept(std::is_nothrow_assignable<F &, F2>::value &&
                     std::is_nothrow_assignable<S &, S2>::value)
        {
            this->first = static_cast<F2 &&>(that.first);
            this->second = static_cast<S2 &&>(that.second);
            return *this;
        }

         template<typename F2, typename S2 > requires assignable_from<F const &, F2 &> && assignable_from<S const &, S2 &>
#line 422 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair const & operator=(std::pair<F2, S2> & that) const 
            noexcept(std::is_nothrow_assignable<F const &, F2 &>::value &&
                     std::is_nothrow_assignable<S const &, S2 &>::value)
        {
            this->first = that.first;
            this->second = that.second;
            return *this;
        }
         template<typename F2, typename S2 > requires assignable_from<F const &, F2 const &> && assignable_from<S const &, S2 const &>
#line 433 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair const & operator=(std::pair<F2, S2> const & that) const 
            noexcept(std::is_nothrow_assignable<F const &, F2 const &>::value &&
                     std::is_nothrow_assignable<S const &, S2 const &>::value)
        {
            this->first = that.first;
            this->second = that.second;
            return *this;
        }
         template<typename F2, typename S2 > requires assignable_from<F const &, F2> && assignable_from<S const &, S2>
#line 443 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
        common_pair const & operator=(std::pair<F2, S2> && that) const 
            noexcept(std::is_nothrow_assignable<F const &, F2 &&>::value &&
                     std::is_nothrow_assignable<S const &, S2 &&>::value)
        {
            this->first = static_cast<F2 &&>(that.first);
            this->second = static_cast<S2 &&>(that.second);
            return *this;
        }
    };

    
     template<typename F1, typename S1, typename F2, typename S2 > requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>
#line 456 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
    bool operator==(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b)
    {
        return a.first == b.first && a.second == b.second;
    }
     template<typename F1, typename S1, typename F2, typename S2 > requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>
#line 462 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
    bool operator==(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b)
    {
        return a.first == b.first && a.second == b.second;
    }
     template<typename F1, typename S1, typename F2, typename S2 > requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2>
#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
    bool operator==(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b)
    {
        return a.first == b.first && a.second == b.second;
    }
     template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>
#line 474 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
    bool operator<(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b)
    {
        return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
    }
     template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>
#line 480 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
    bool operator<(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b)
    {
        return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
    }
     template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2>
#line 486 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
    bool operator<(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b)
    {
        return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
    }




















     template<typename F1, typename S1, typename F2, typename S2 > requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2> bool operator !=(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return !(a == b); }  template<typename F1, typename S1, typename F2, typename S2 > requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2> bool operator !=(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return !(a == b); }  template<typename F1, typename S1, typename F2, typename S2 > requires equality_comparable_with<F1, F2> && equality_comparable_with<S1, S2> bool operator !=(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b) { return !(a == b); }
     template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator <=(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return !(b < a); }  template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator <=(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return !(b < a); }  template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator <=(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b) { return !(b < a); }
     template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator >(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return (b < a); }  template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator >(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return (b < a); }  template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator >(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b) { return (b < a); }
     template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator >=(common_pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return !(a < b); }  template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator >=(std::pair<F1, S1> const & a, common_pair<F2, S2> const & b) { return !(a < b); }  template<typename F1, typename S1, typename F2, typename S2 > requires totally_ordered_with<F1, F2> && totally_ordered_with<S1, S2> bool operator >=(common_pair<F1, S1> const & a, std::pair<F2, S2> const & b) { return !(a < b); }


    struct make_common_pair_fn
    {
        template<typename First, typename Second, typename F = bind_element_t<First>,
                 typename S = bind_element_t<Second>>
        common_pair<F, S> operator()(First && f, Second && s) const 
            noexcept(std::is_nothrow_constructible<F, unwrap_reference_t<First>>::value &&
                     std::is_nothrow_constructible<F, unwrap_reference_t<Second>>::value)
        {
            return {unwrap_reference(static_cast<First &&>(f)),
                    unwrap_reference(static_cast<Second &&>(s))};
        }
    };

    
    
    inline constexpr make_common_pair_fn make_common_pair{};

    
    namespace detail
    {
        template<typename, typename, typename, typename = void>
        struct common_type_tuple_like
        {};

        template<template<typename...> class T0, typename... Ts,
                 template<typename...> class T1, typename... Us, typename TupleLike>
        struct common_type_tuple_like<T0<Ts...>, T1<Us...>, TupleLike,
                                      meta::if_c<sizeof...(Ts) == sizeof...(Us)>>
          : meta::lazy::let<
                meta::lazy::invoke<TupleLike, meta::lazy::_t<common_type<Ts, Us>>...>>
        {};

        template<typename, typename, typename, typename = void>
        struct common_ref_tuple_like
        {};

        template<template<typename...> class T0, typename... Ts,
                 template<typename...> class T1, typename... Us, typename TupleLike>
        struct common_ref_tuple_like<T0<Ts...>, T1<Us...>, TupleLike,
                                     meta::if_c<sizeof...(Ts) == sizeof...(Us)>>
          : meta::lazy::let<meta::lazy::invoke<
                TupleLike, meta::lazy::_t<common_reference<Ts, Us>>...>>
        {};
    } 
    
} 


namespace concepts
{
    
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<std::pair<F1, S1>, ranges::common_pair<F2, S2>>
      : ranges::detail::common_type_tuple_like<
            std::pair<F1, S1>, ranges::common_pair<F2, S2>,
            meta::quote<ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<ranges::common_pair<F1, S1>, std::pair<F2, S2>>
      : ranges::detail::common_type_tuple_like<
            ranges::common_pair<F1, S1>, std::pair<F2, S2>,
            meta::quote<ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<ranges::common_pair<F1, S1>, ranges::common_pair<F2, S2>>
      : ranges::detail::common_type_tuple_like<ranges::common_pair<F1, S1>,
                                               ranges::common_pair<F2, S2>,
                                               meta::quote<ranges::common_pair>>
    {};
    
    template<typename... Ts, typename... Us>
    struct common_type<ranges::common_tuple<Ts...>, std::tuple<Us...>>
      : ranges::detail::common_type_tuple_like<
            ranges::common_tuple<Ts...>, std::tuple<Us...>,
            meta::quote<ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us>
    struct common_type<std::tuple<Ts...>, ranges::common_tuple<Us...>>
      : ranges::detail::common_type_tuple_like<
            std::tuple<Ts...>, ranges::common_tuple<Us...>,
            meta::quote<ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us>
    struct common_type<ranges::common_tuple<Ts...>, ranges::common_tuple<Us...>>
      : ranges::detail::common_type_tuple_like<ranges::common_tuple<Ts...>,
                                               ranges::common_tuple<Us...>,
                                               meta::quote<ranges::common_tuple>>
    {};

    
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<ranges::common_pair<F1, S1>, std::pair<F2, S2>, Qual1,
                                  Qual2>
      : ranges::detail::common_ref_tuple_like<
            ranges::common_pair<Qual1<F1>, Qual1<S1>>, std::pair<Qual2<F2>, Qual2<S2>>,
            meta::quote<ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<std::pair<F1, S1>, ranges::common_pair<F2, S2>, Qual1,
                                  Qual2>
      : ranges::detail::common_ref_tuple_like<
            std::pair<Qual1<F1>, Qual1<S1>>, ranges::common_pair<Qual2<F2>, Qual2<S2>>,
            meta::quote<ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<ranges::common_pair<F1, S1>,
                                  ranges::common_pair<F2, S2>, Qual1, Qual2>
      : ranges::detail::common_ref_tuple_like<ranges::common_pair<Qual1<F1>, Qual1<S1>>,
                                              ranges::common_pair<Qual2<F2>, Qual2<S2>>,
                                              meta::quote<ranges::common_pair>>
    {};
    
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<ranges::common_tuple<Ts...>, std::tuple<Us...>, Qual1,
                                  Qual2>
      : ranges::detail::common_ref_tuple_like<
            ranges::common_tuple<Qual1<Ts>...>, std::tuple<Qual2<Us>...>,
            meta::quote<ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<std::tuple<Ts...>, ranges::common_tuple<Us...>, Qual1,
                                  Qual2>
      : ranges::detail::common_ref_tuple_like<
            std::tuple<Qual1<Ts>...>, ranges::common_tuple<Qual2<Us>...>,
            meta::quote<ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<ranges::common_tuple<Ts...>,
                                  ranges::common_tuple<Us...>, Qual1, Qual2>
      : ranges::detail::common_ref_tuple_like<ranges::common_tuple<Qual1<Ts>...>,
                                              ranges::common_tuple<Qual2<Us>...>,
                                              meta::quote<ranges::common_tuple>>
    {};
} 


__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))
namespace std {
    template<typename First, typename Second>
    struct tuple_size<::ranges::common_pair<First, Second>>
      : std::integral_constant<size_t, 2>
    {};

    template<typename First, typename Second>
    struct tuple_element<0, ::ranges::common_pair<First, Second>>
    {
        using type = First;
    };

    template<typename First, typename Second>
    struct tuple_element<1, ::ranges::common_pair<First, Second>>
    {
        using type = Second;
    };

    template<typename... Ts>
    struct tuple_size<::ranges::common_tuple<Ts...>>
      : std::integral_constant<size_t, sizeof...(Ts)>
    {};

    template<size_t N, typename... Ts>
    struct tuple_element<N, ::ranges::common_tuple<Ts...>>
      : tuple_element<N, tuple<Ts...>>
    {};



    template<typename...>
    struct common_type;

    
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<std::pair<F1, S1>, ::ranges::common_pair<F2, S2>>
      : ::ranges::detail::common_type_tuple_like<
            std::pair<F1, S1>, ::ranges::common_pair<F2, S2>,
            ::meta::quote<::ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<::ranges::common_pair<F1, S1>, std::pair<F2, S2>>
      : ::ranges::detail::common_type_tuple_like<
            ::ranges::common_pair<F1, S1>, std::pair<F2, S2>,
            ::meta::quote<::ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2>
    struct common_type<::ranges::common_pair<F1, S1>, ::ranges::common_pair<F2, S2>>
      : ::ranges::detail::common_type_tuple_like<::ranges::common_pair<F1, S1>,
                                               ::ranges::common_pair<F2, S2>,
                                               ::meta::quote<::ranges::common_pair>>
    {};
    
    template<typename... Ts, typename... Us>
    struct common_type<::ranges::common_tuple<Ts...>, std::tuple<Us...>>
      : ::ranges::detail::common_type_tuple_like<
            ::ranges::common_tuple<Ts...>, std::tuple<Us...>,
            ::meta::quote<::ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us>
    struct common_type<std::tuple<Ts...>, ::ranges::common_tuple<Us...>>
      : ::ranges::detail::common_type_tuple_like<
            std::tuple<Ts...>, ::ranges::common_tuple<Us...>,
            ::meta::quote<::ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us>
    struct common_type<::ranges::common_tuple<Ts...>, ::ranges::common_tuple<Us...>>
      : ::ranges::detail::common_type_tuple_like<::ranges::common_tuple<Ts...>,
                                               ::ranges::common_tuple<Us...>,
                                               ::meta::quote<::ranges::common_tuple>>
    {};

    template<typename, typename, template<typename> class, template<typename> class>
    struct basic_common_reference;

    
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_pair<F1, S1>, std::pair<F2, S2>, Qual1,
                                  Qual2>
      : ::ranges::detail::common_ref_tuple_like<
            ::ranges::common_pair<Qual1<F1>, Qual1<S1>>, std::pair<Qual2<F2>, Qual2<S2>>,
            ::meta::quote<::ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<std::pair<F1, S1>, ::ranges::common_pair<F2, S2>, Qual1,
                                  Qual2>
      : ::ranges::detail::common_ref_tuple_like<
            std::pair<Qual1<F1>, Qual1<S1>>, ::ranges::common_pair<Qual2<F2>, Qual2<S2>>,
            ::meta::quote<::ranges::common_pair>>
    {};
    template<typename F1, typename S1, typename F2, typename S2,
             template<typename> class Qual1, template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_pair<F1, S1>,
                                  ::ranges::common_pair<F2, S2>, Qual1, Qual2>
      : ::ranges::detail::common_ref_tuple_like<::ranges::common_pair<Qual1<F1>, Qual1<S1>>,
                                              ::ranges::common_pair<Qual2<F2>, Qual2<S2>>,
                                              ::meta::quote<::ranges::common_pair>>
    {};
    
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_tuple<Ts...>, std::tuple<Us...>, Qual1,
                                  Qual2>
      : ::ranges::detail::common_ref_tuple_like<
            ::ranges::common_tuple<Qual1<Ts>...>, std::tuple<Qual2<Us>...>,
            ::meta::quote<::ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<std::tuple<Ts...>, ::ranges::common_tuple<Us...>, Qual1,
                                  Qual2>
      : ::ranges::detail::common_ref_tuple_like<
            std::tuple<Qual1<Ts>...>, ::ranges::common_tuple<Qual2<Us>...>,
            ::meta::quote<::ranges::common_tuple>>
    {};
    template<typename... Ts, typename... Us, template<typename> class Qual1,
             template<typename> class Qual2>
    struct basic_common_reference<::ranges::common_tuple<Ts...>,
                                  ::ranges::common_tuple<Us...>, Qual1, Qual2>
      : ::ranges::detail::common_ref_tuple_like<::ranges::common_tuple<Qual1<Ts>...>,
                                              ::ranges::common_tuple<Qual2<Us>...>,
                                              ::meta::quote<::ranges::common_tuple>>
    {};

#line 787 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
}
__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 791 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"

#line 793 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/common_tuple.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        template<typename I, typename S>
        variant<I, S> & cidata(common_iterator<I, S> & that)
        {
            return that.data_;
        }

        template<typename I, typename S>
        variant<I, S> const & cidata(common_iterator<I, S> const & that)
        {
            return that.data_;
        }
    } 







#line 62 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    

    template<typename I, typename S>
    struct common_iterator


#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    {
    private:
        static_assert(static_cast<bool>(input_or_output_iterator<I>), "Concept assertion failed : " "input_or_output_iterator<I>");
        static_assert(static_cast<bool>(sentinel_for<S, I>), "Concept assertion failed : " "sentinel_for<S, I>");
        static_assert(static_cast<bool>(!same_as<I, S>), "Concept assertion failed : " "!same_as<I, S>");
        variant<I, S> data_;

        friend variant<I, S> & detail::cidata<>(common_iterator<I, S> &);
        friend variant<I, S> const & detail::cidata<>(common_iterator<I, S> const &);
        struct emplace_fn
        {
            variant<I, S> * data_;
            template<typename T, std::size_t N>
            void operator()(indexed_element<T, N> t) const
            {
                ranges::emplace<N>(*data_, t.get());
            }
        };
        struct arrow_proxy_
        {
        private:
            friend common_iterator;
            iter_value_t<I> keep_;
            arrow_proxy_(iter_reference_t<I> && x)
              : keep_(std::move(x))
            {}

        public:
            const iter_value_t<I> * operator->() const noexcept
            {
                return std::addressof(keep_);
            }
        };
        template<typename T>
        static T * operator_arrow_(T * p, int) noexcept
        {
            return p;
        }
        template<typename J, typename = detail::iter_arrow_t<J const>>
        static J operator_arrow_(J const & j, int) noexcept(noexcept(J(j)))
        {
            return j;
        }
         template<typename J, typename R = iter_reference_t<J> > requires std::is_reference<R>::value 
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        static meta::_t<std::add_pointer<R>> operator_arrow_(J const & j, long) noexcept
        {
            auto && r = *j;
            return std::addressof(r);
        }
         template<typename J, typename V = iter_value_t<J> > requires constructible_from<V, iter_reference_t<J>>
#line 121 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        static arrow_proxy_ operator_arrow_(J const & j, ...) noexcept(noexcept(V(V(*j))))
        {
            return arrow_proxy_(*j);
        }

    public:
        using difference_type = iter_difference_t<I>;

        common_iterator() = default;
        common_iterator(I i)
          : data_(emplaced_index<0>, std::move(i))
        {}
        common_iterator(S s)
          : data_(emplaced_index<1>, std::move(s))
        {}
         template<typename I2, typename S2 > requires convertible_to<I2, I> && convertible_to<S2, S>
#line 138 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        common_iterator(common_iterator<I2, S2> const & that)
          : data_(detail::variant_core_access::make_empty<I, S>())
        {
            detail::cidata(that).visit_i(emplace_fn{&data_});
        }
         template<typename I2, typename S2 > requires convertible_to<I2, I> && convertible_to<S2, S>
#line 145 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        common_iterator & operator=(common_iterator<I2, S2> const & that)
        {
            detail::cidata(that).visit_i(emplace_fn{&data_});
            return *this;
        }
        iter_reference_t<I> operator*() 
            noexcept(noexcept(iter_reference_t<I>(*std::declval<I &>())))
        {
            return *ranges::get<0>(data_);
        }
        
        auto operator*() const 
            noexcept(noexcept(iter_reference_t<I>(*std::declval<I const &>())))
            -> iter_reference_t<I> requires indirectly_readable<I const>
#line 160 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        {
            return *ranges::get<0>(data_);
        }
         template<typename J = I > requires indirectly_readable<J>
#line 165 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        auto operator->() const 
            noexcept(
                noexcept(common_iterator::operator_arrow_(std::declval<I const &>(), 42)))
            -> decltype(common_iterator::operator_arrow_(std::declval<J const &>(), 42))
        {
            return common_iterator::operator_arrow_(ranges::get<0>(data_), 42);
        }
        common_iterator & operator++()
        {
            ++ranges::get<0>(data_);
            return *this;
        }

         template<typename I2 = I > requires (!forward_iterator<I2>) 
#line 180 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        auto operator++(int) 
            -> decltype(std::declval<I2 &>()++)
        {
            return ranges::get<0>(data_)++;
        }








#line 194 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        
        auto operator++(int) 
            -> common_iterator requires forward_iterator<I>
#line 198 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        {
            return common_iterator(ranges::get<0>(data_)++);
        }


        template<typename I_ = I>
        friend constexpr auto iter_move(common_iterator const & i) 
            noexcept(detail::has_nothrow_iter_move_v<I>)
            -> ::concepts::return_t< iter_rvalue_reference_t<I>, std::enable_if_t<( input_iterator<I_> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 208 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        {
            return ranges::iter_move(ranges::get<0>(detail::cidata(i)));
        }
        template<typename I2, typename S2>
        friend auto iter_swap(
            common_iterator const & x,
            common_iterator<I2, S2> const &
                y) noexcept(is_nothrow_indirectly_swappable<I, I2>::value)
            -> ::concepts::return_t< void, std::enable_if_t<( indirectly_swappable<I2, I> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 218 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        {
            return ranges::iter_swap(ranges::get<0>(detail::cidata(x)),
                                     ranges::get<0>(detail::cidata(y)));
        }
#line 223 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    };

    






















#line 249 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    

     template<typename I1, typename I2, typename S1, typename S2 > requires sentinel_for<S1, I2> && sentinel_for<S2, I1> && (!equality_comparable_with<I1, I2>) 
#line 254 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    bool operator==(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
    {
        return detail::cidata(x).index() == 1u ? (detail::cidata(y).index() == 1u ||
                                                  ranges::get<0>(detail::cidata(y)) ==
                                                      ranges::get<1>(detail::cidata(x)))
                                               : (detail::cidata(y).index() != 1u ||
                                                  ranges::get<0>(detail::cidata(x)) ==
                                                      ranges::get<1>(detail::cidata(y)));
    }

     template<typename I1, typename I2, typename S1, typename S2 > requires sentinel_for<S1, I2> && sentinel_for<S2, I1> && equality_comparable_with<I1, I2>
#line 267 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    bool operator==(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
    {
        return detail::cidata(x).index() == 1u
                   ? (detail::cidata(y).index() == 1u ||
                      ranges::get<0>(detail::cidata(y)) ==
                          ranges::get<1>(detail::cidata(x)))
                   : (detail::cidata(y).index() == 1u
                          ? ranges::get<0>(detail::cidata(x)) ==
                                ranges::get<1>(detail::cidata(y))
                          : ranges::get<0>(detail::cidata(x)) ==
                                ranges::get<0>(detail::cidata(y)));
    }

     template<typename I1, typename I2, typename S1, typename S2 > requires sentinel_for<S1, I2> && sentinel_for<S2, I1>
#line 282 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    bool operator!=(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
    {
        return !(x == y);
    }

     template<typename I1, typename I2, typename S1, typename S2 > requires sized_sentinel_for<I1, I2> && sized_sentinel_for<S1, I2> && sized_sentinel_for<S2, I1>
#line 290 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
    iter_difference_t<I2> operator-(common_iterator<I1, S1> const & x,
                                    common_iterator<I2, S2> const & y)
    {
        return detail::cidata(x).index() == 1u
                   ? (detail::cidata(y).index() == 1u
                          ? 0
                          : ranges::get<1>(detail::cidata(x)) -
                                ranges::get<0>(detail::cidata(y)))
                   : (detail::cidata(y).index() == 1u
                          ? ranges::get<0>(detail::cidata(x)) -
                                ranges::get<1>(detail::cidata(y))
                          : ranges::get<0>(detail::cidata(x)) -
                                ranges::get<0>(detail::cidata(y)));
    }

    template<typename I, typename S>
    struct indirectly_readable_traits<common_iterator<I, S>>
      : meta::if_c<
        (bool)indirectly_readable<I>,
        indirectly_readable_traits<I>,
        meta::nil_>
    {};

    
    namespace detail
    {
        template<typename I>
        auto demote_common_iter_cat(...) -> nil_;
        template<typename I>
        auto demote_common_iter_cat(long)
            -> with_iterator_category<std::input_iterator_tag>;
         template<typename I > requires derived_from<typename std::iterator_traits<I>::iterator_category, std::forward_iterator_tag>
#line 324 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
        auto demote_common_iter_cat(int)
            -> with_iterator_category<std::forward_iterator_tag>;

        template<typename I, bool = (bool)input_iterator<I>>
        struct common_iterator_std_traits : decltype(detail::demote_common_iter_cat<I>(0))
        {
            using difference_type = iter_difference_t<I>;
            using value_type = iter_value_t<I>;
            using reference = iter_reference_t<I>;
            using pointer = detail::iter_pointer_t<I>;
            using iterator_concept =
                meta::conditional_t<(bool)forward_iterator<I>, std::forward_iterator_tag,
                          std::input_iterator_tag>;
        };

        template<typename I>
        struct common_iterator_std_traits<I, false>
        {
            using difference_type = iter_difference_t<I>;
            using value_type = void;
            using reference = void;
            using pointer = void;
            using iterator_category = std::output_iterator_tag;
        };

        
        
        
        template<typename I>
        struct cpp17_iterator_cursor
        {
        private:
            friend range_access;
            I it_;
            struct mixin : basic_mixin<cpp17_iterator_cursor>
            {
                mixin() = default;
                


                constexpr explicit mixin(cpp17_iterator_cursor && cur)
                  : basic_mixin<cpp17_iterator_cursor>(
                        static_cast<cpp17_iterator_cursor &&>(cur))
                {}
                constexpr explicit mixin(cpp17_iterator_cursor const & cur)
                  : basic_mixin<cpp17_iterator_cursor>(cur)
                {}
                #line 372 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
                explicit mixin(I it)
                  : mixin{cpp17_iterator_cursor{std::move(it)}}
                {}
                I base() const
                {
                    return this->get().it_;
                }
            };

        public:
            using single_pass = meta::bool_<!forward_iterator<I>>;
            using difference_type = std::ptrdiff_t;
            using value_type = iter_value_t<I>;

            cpp17_iterator_cursor() = default;
            constexpr explicit cpp17_iterator_cursor(I i)
              : it_(static_cast<I &&>(i))
            {}

            I arrow() const
            {
                return it_;
            }
            decltype(auto) read()
            {
                return *it_;
            }
            decltype(auto) read() const
            {
                return *it_;
            }
            void next()
            {
                ++it_;
            }
            bool equal(cpp17_iterator_cursor const & that) const
            {
                return it_ == that.it_;
            }
            
            auto prev() 
                -> void requires bidirectional_iterator<I>
#line 415 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
            {
                --it_;
            }
            
            auto advance(std::ptrdiff_t n) 
                -> void requires random_access_iterator<I>
#line 422 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
            {
                it_ += static_cast<iter_difference_t<I>>(n);
            }
            
            auto distance_to(cpp17_iterator_cursor const & that) 
                -> std::ptrdiff_t requires random_access_iterator<I>
#line 429 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
            {
                auto d = that.it_ - it_;
                static_cast<void>((d <= 9223372036854775807i64) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp", 431, "assertion failed: " "d <= 9223372036854775807i64"));
                return static_cast<std::ptrdiff_t>(d);
            }
        };
    } 
    

    namespace cpp20
    {
        using ranges::common_iterator;
    }
    
} 


__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))

namespace std
{
    template<typename I, typename S>
    struct iterator_traits<::ranges::common_iterator<I, S>>
      : ::ranges::detail::common_iterator_std_traits<I>
    {};
} 

__pragma(warning(pop))


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 461 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"

#line 463 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/common_iterator.hpp"
#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"




#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"

namespace ranges
{
    
    namespace detail
    {
        struct to_container
        {
            template<typename MetaFn>
            struct fn;

            template<typename MetaFn, typename Fn>
            struct closure;

            template<typename MetaFn, typename Rng>
            using container_t = meta::invoke<MetaFn, Rng>;

            template<typename Rng, typename MetaFn>
            friend auto operator|(Rng && rng,
                                  closure<MetaFn, fn<MetaFn>> (*)(to_container))
                -> ::concepts::return_t< container_t<MetaFn, Rng>, std::enable_if_t<( invocable<fn<MetaFn>, Rng> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return fn<MetaFn>{}(static_cast<Rng &&>(rng));
            }

            template<typename MetaFn, typename Pipeable>
            friend auto operator|(closure<MetaFn, fn<MetaFn>> (*)(to_container),
                                  Pipeable pipe)
                -> ::concepts::return_t< closure<MetaFn, composed<Pipeable, fn<MetaFn>>>, std::enable_if_t<( (is_pipeable_v<Pipeable>) && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return closure<MetaFn, composed<Pipeable, fn<MetaFn>>>{
                    compose(static_cast<Pipeable &&>(pipe), fn<MetaFn>{})};
            }
        };

        
        
        
        template<typename Rng, typename Cont>
        struct to_container_iterator
        {
        private:
            using I = range_cpp17_iterator_t<Rng>;
            using ValueType = range_value_t<Cont>;
            I it_;

        public:
            using difference_type = typename std::iterator_traits<I>::difference_type;
            using value_type = ValueType;
            using reference = ValueType;
            using pointer = typename std::iterator_traits<I>::pointer;
            using iterator_category = typename std::iterator_traits<I>::iterator_category;

            to_container_iterator() = default;
            template<typename OtherIt>
            to_container_iterator(OtherIt it)
              : it_(std::move(it))
            {}
            friend bool operator==(to_container_iterator const & a,
                                   to_container_iterator const & b)
            {
                return a.it_ == b.it_;
            }
            friend bool operator!=(to_container_iterator const & a,
                                   to_container_iterator const & b)
            {
                return !(a == b);
            }
            reference operator*() const
            {
                return to_container::fn<meta::id<ValueType>>{}(*it_);
            }
            to_container_iterator & operator++()
            {
                ++it_;
                return *this;
            }
            to_container_iterator operator++(int)
            {
                auto tmp = *this;
                ++it_;
                return tmp;
            }
            
            auto operator--() 
                -> to_container_iterator & requires derived_from<iterator_category, std::bidirectional_iterator_tag>
#line 122 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                --it_;
                return *this;
            }
            
            auto operator--(int) 
                -> to_container_iterator & requires derived_from<iterator_category, std::bidirectional_iterator_tag>
#line 131 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                auto tmp = *this;
                ++it_;
                return tmp;
            }
            
            auto operator+=(difference_type n) 
                -> to_container_iterator & requires derived_from<iterator_category, std::random_access_iterator_tag>
#line 141 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                it_ += n;
                return *this;
            }
            
            auto operator-=(difference_type n) 
                -> to_container_iterator & requires derived_from<iterator_category, std::random_access_iterator_tag>
#line 150 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                it_ -= n;
                return *this;
            }
            template<::concepts::detail::CPP_true_t const &CPP_true_fn = ::concepts::detail::CPP_true_fn_>
            friend auto operator+(to_container_iterator i, difference_type n) 
                -> ::concepts::return_t< to_container_iterator, std::enable_if_t<( derived_from<iterator_category, std::random_access_iterator_tag> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 159 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return i += n;
            }
            template<::concepts::detail::CPP_true_t const &CPP_true_fn = ::concepts::detail::CPP_true_fn_>
            friend auto operator-(to_container_iterator i, difference_type n) 
                -> ::concepts::return_t< to_container_iterator, std::enable_if_t<( derived_from<iterator_category, std::random_access_iterator_tag> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 167 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return i -= n;
            }
            template<::concepts::detail::CPP_true_t const &CPP_true_fn = ::concepts::detail::CPP_true_fn_>
            friend auto operator-(difference_type n, to_container_iterator i) 
                -> ::concepts::return_t< to_container_iterator, std::enable_if_t<( derived_from<iterator_category, std::random_access_iterator_tag> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 175 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return i -= n;
            }
            template<::concepts::detail::CPP_true_t const &CPP_true_fn = ::concepts::detail::CPP_true_fn_>
            friend auto operator-(to_container_iterator const & i,
                                  to_container_iterator const & j) 
                -> ::concepts::return_t< difference_type, std::enable_if_t<( derived_from<iterator_category, std::random_access_iterator_tag> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return i.it_ - j.it_;
            }
            
            auto operator[](difference_type n) const 
                -> reference requires derived_from<iterator_category, std::random_access_iterator_tag>
#line 192 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return *(*this + n);
            }
        };

        template<typename Rng, typename Cont>
        using to_container_iterator_t =
            enable_if_t<(bool)range<Rng>, to_container_iterator<Rng, Cont>>;

        
        
        
         template<typename Rng > concept range_and_not_view_concept_ = range<Rng> && (!view_<Rng>);
#line 207 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"

        
        
        template<typename Rng>
        concept range_and_not_view =
            range_and_not_view_concept_<Rng>;

        
        
         template<typename Rng, typename Cont > concept convertible_to_cont_impl_concept_ = constructible_from<range_value_t<Cont>, range_reference_t<Rng>> && constructible_from< Cont, range_cpp17_iterator_t<Rng>, range_cpp17_iterator_t<Rng>>;
#line 224 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        
        
        template<typename Rng, typename Cont>
        concept convertible_to_cont = 
            range_and_not_view<Cont> && 
            move_constructible<Cont> && 
            detail::convertible_to_cont_impl_concept_<Rng, Cont>;

        
        
         template<typename Rng, typename Cont > concept convertible_to_cont_cont_impl_concept_ = range_and_not_view<range_value_t<Cont>> && invocable< to_container::fn<meta::id<range_value_t<Cont>>>, range_reference_t<Rng>> && constructible_from< Cont, to_container_iterator_t<Rng, Cont>, to_container_iterator_t<Rng, Cont>>;
#line 247 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        
        
        template<typename Rng, typename Cont>
        concept convertible_to_cont_cont = 
            range<Cont> && 
            (!view_<Cont>) && 
            move_constructible<Cont> && 
            detail::convertible_to_cont_cont_impl_concept_<Rng, Cont>;

        
        
        template<typename C, typename I, typename R>
        concept to_container_reserve = 
            reservable_with_assign<C, I> && 
            sized_range<R>;

        template<typename MetaFn, typename Rng>
        using container_t = meta::invoke<MetaFn, Rng>;
        

        struct _ranges_adl_barrier_noop_; namespace to_container_closure_base_ns { struct to_container_closure_base; } using to_container_closure_base_ns::to_container_closure_base; struct to_container_closure_base_ns::to_container_closure_base
        {
            
             template<typename Rng, typename MetaFn, typename Fn > requires input_range<Rng> && convertible_to_cont<Rng, container_t<MetaFn, Rng>>
#line 273 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            friend constexpr auto
            operator|(Rng && rng, to_container::closure<MetaFn, Fn> fn)
            {
                return static_cast<Fn &&>(fn)(static_cast<Rng &&>(rng));
            }

             template<typename Rng, typename MetaFn, typename Fn > requires input_range<Rng> && (!convertible_to_cont<Rng, container_t<MetaFn, Rng>>) && convertible_to_cont_cont<Rng, container_t<MetaFn, Rng>>
#line 283 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            friend constexpr auto
            operator|(Rng && rng, to_container::closure<MetaFn, Fn> fn)
            {
                return static_cast<Fn &&>(fn)(static_cast<Rng &&>(rng));
            }

            template<typename MetaFn, typename Fn, typename Pipeable>
            friend constexpr auto operator|(to_container::closure<MetaFn, Fn> sh,
                                            Pipeable pipe)
                -> ::concepts::return_t< to_container::closure<MetaFn, composed<Pipeable, Fn>>, std::enable_if_t<( is_pipeable_v<Pipeable> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 295 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            {
                return to_container::closure<MetaFn, composed<Pipeable, Fn>>{
                    compose(static_cast<Pipeable &&>(pipe), static_cast<Fn &&>(sh))};
            }
        };

        template<typename MetaFn, typename Fn>
        struct to_container::closure
          : to_container_closure_base
          , Fn
        {
            closure() = default;
            constexpr explicit closure(Fn fn)
              : Fn(static_cast<Fn &&>(fn))
            {}
        };

        template<typename MetaFn>
        struct to_container::fn
        {
        private:
            template<typename Cont, typename I, typename Rng>
            static Cont impl(Rng && rng, std::false_type)
            {
                return Cont(I{ranges::begin(rng)}, I{ranges::end(rng)});
            }
            template<typename Cont, typename I, typename Rng>
            static auto impl(Rng && rng, std::true_type)
            {
                Cont c;
                auto const rng_size = ranges::size(rng);
                using size_type = decltype(c.max_size());
                using C = common_type_t<range_size_t<Rng>, size_type>;
                static_cast<void>((static_cast<C>(rng_size) <= static_cast<C>(c.max_size())) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp", 328, "assertion failed: " "static_cast<C>(rng_size) <= static_cast<C>(c.max_size())"));
                c.reserve(static_cast<size_type>(rng_size));
                c.assign(I{ranges::begin(rng)}, I{ranges::end(rng)});
                return c;
            }

        public:
             template<typename Rng > requires input_range<Rng> && convertible_to_cont<Rng, container_t<MetaFn, Rng>>
#line 338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            container_t<MetaFn, Rng> operator()(Rng && rng) const
            {
                static_assert(!is_infinite<Rng>::value,
                              "Attempt to convert an infinite range to a container.");
                using cont_t = container_t<MetaFn, Rng>;
                using iter_t = range_cpp17_iterator_t<Rng>;
                using use_reserve_t =
                    meta::bool_<(bool)to_container_reserve<cont_t, iter_t, Rng>>;
                return impl<cont_t, iter_t>(static_cast<Rng &&>(rng), use_reserve_t{});
            }
             template<typename Rng > requires input_range<Rng> && (!convertible_to_cont<Rng, container_t<MetaFn, Rng>>) && convertible_to_cont_cont<Rng, container_t<MetaFn, Rng>>
#line 352 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
            container_t<MetaFn, Rng> operator()(Rng && rng) const
            {
                static_assert(!is_infinite<Rng>::value,
                              "Attempt to convert an infinite range to a container.");
                using cont_t = container_t<MetaFn, Rng>;
                using iter_t = to_container_iterator<Rng, cont_t>;
                using use_reserve_t =
                    meta::bool_<(bool)to_container_reserve<cont_t, iter_t, Rng>>;
                return impl<cont_t, iter_t>(static_cast<Rng &&>(rng), use_reserve_t{});
            }
        };

        template<typename MetaFn, typename Fn>
        using to_container_closure = to_container::closure<MetaFn, Fn>;

        template<typename MetaFn>
        using to_container_fn = to_container_closure<MetaFn, to_container::fn<MetaFn>>;

        template<template<typename...> class ContT>
        struct from_range
        {

            
            template<typename Rng>
            static auto from_rng_(int) 
                -> decltype(ContT(range_cpp17_iterator_t<Rng>{},
                                  range_cpp17_iterator_t<Rng>{}));
            
            
            template<typename Rng>
            static auto from_rng_(long) 
                -> meta::invoke<meta::quote<ContT>, range_value_t<Rng>>;

            template<typename Rng>
            using invoke = decltype(from_range::from_rng_<Rng>(0));



#line 391 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        };
    } 
    

    
    

    
    inline constexpr detail::to_container_fn<detail::from_range<std::vector>> to_vector{};
#line 401 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"

    
    namespace _to_
    {
        

        
        
        template<template<typename...> class ContT>
        auto to(detail::to_container = {})
            -> detail::to_container_fn<detail::from_range<ContT>>
        {
            return {};
        }

        
         template<template<typename...> class ContT, typename Rng, typename C = meta::invoke<detail::from_range<ContT>, Rng> > requires range<Rng> && detail::convertible_to_cont<Rng, C>
#line 420 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        auto to(Rng && rng) -> C
        {
            return detail::to_container_fn<detail::from_range<ContT>>{}(
                static_cast<Rng &&>(rng));
        }

        
        template<typename Cont>
        auto to(detail::to_container = {})
            -> detail::to_container_fn<meta::id<Cont>>
        {
            return {};
        }

        
         template<typename Cont, typename Rng > requires range<Rng> && detail::convertible_to_cont<Rng, Cont>
#line 437 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        auto to(Rng && rng) -> Cont
        {
            return detail::to_container_fn<meta::id<Cont>>{}(static_cast<Rng &&>(rng));
        }

        
         template<typename Cont, typename Rng > requires input_range<Rng> && (!detail::convertible_to_cont<Rng, Cont>) && detail::convertible_to_cont_cont<Rng, Cont>
#line 447 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        auto to(Rng && rng) -> Cont
        {
            return detail::to_container_fn<meta::id<Cont>>{}(static_cast<Rng &&>(rng));
        }

        
        
         template<template<typename...> class ContT, typename T > requires detail::convertible_to_cont<std::initializer_list<T>, ContT<T>>
#line 456 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        auto to(std::initializer_list<T> il) -> ContT<T>
        {
            return detail::to_container_fn<detail::from_range<ContT>>{}(il);
        }
         template<typename Cont, typename T > requires detail::convertible_to_cont<std::initializer_list<T>, Cont>
#line 462 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        auto to(std::initializer_list<T> il) -> Cont
        {
            return detail::to_container_fn<meta::id<Cont>>{}(il);
        }
        

        
    } 
    using namespace _to_;
    
    

    
    
    namespace _to_
    {
        
        template<template<typename...> class ContT>
        [[deprecated("Please use ranges::to (no underscore) instead.")]]
        detail::to_container_fn<detail::from_range<ContT>> to_(detail::to_container = {})
        {
            return {};
        }
         template<template<typename...> class ContT, typename Rng > requires range<Rng> && detail::convertible_to_cont<Rng, ContT<range_value_t<Rng>>>
#line 488 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        [[deprecated("Please use ranges::to (no underscore) instead.")]]
        ContT<range_value_t<Rng>> to_(Rng && rng)
        {
            return static_cast<Rng &&>(rng) | ranges::to_<ContT>();
        }
         template<template<typename...> class ContT, typename T > requires detail::convertible_to_cont<std::initializer_list<T>, ContT<T>>
#line 495 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        [[deprecated("Please use ranges::to (no underscore) instead.")]]
        ContT<T> to_(std::initializer_list<T> il)
        {
            return il | ranges::to_<ContT>();
        }
        template<typename Cont>
        [[deprecated("Please use ranges::to (no underscore) instead.")]]
        detail::to_container_fn<meta::id<Cont>> to_(detail::to_container = {})
        {
            return {};
        }
         template<typename Cont, typename Rng > requires range<Rng> && detail::convertible_to_cont<Rng, Cont>
#line 508 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        [[deprecated("Please use ranges::to (no underscore) instead.")]]
        Cont to_(Rng && rng)
        {
            return static_cast<Rng &&>(rng) | ranges::to_<Cont>();
        }
         template<typename Cont, typename T > requires detail::convertible_to_cont<std::initializer_list<T>, Cont>
#line 515 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
        [[deprecated("Please use ranges::to (no underscore) instead.")]]
        Cont to_(std::initializer_list<T> list)
        {
            return list | ranges::to_<Cont>();
        }
    } 
    

    template<typename MetaFn, typename Fn>
    inline constexpr bool
        is_pipeable_v<detail::to_container_closure<MetaFn, Fn>> = true;
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 529 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"

#line 531 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/conversion.hpp"
#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/grammars/schemagrammar.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"






























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"

namespace ranges
{
    
    
    struct max_fn {

        
         template<typename T, typename C = less, typename P = identity > requires indirect_strict_weak_order<C, projected<T const *, P>>
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"
        constexpr T const & operator() (T const & a, T const & b, C pred = C{}, P proj = P{}) const 
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"
        {
            return invoke(pred, invoke(proj, b), invoke(proj, a)) ? a : b;
        }

        
         template<typename Rng, typename C = less, typename P = identity > requires input_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> && indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"
        constexpr range_value_t<Rng> 
        operator() (Rng && rng, C pred = C{}, P proj = P{}) const 
        {
            auto first = ranges::begin(rng);
            auto last = ranges::end(rng);
            static_cast<void>((first != last) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp", 58, "assertion failed: " "first != last"));
            range_value_t<Rng> result = *first;
            while(++first != last)
            {
                auto && tmp = *first;
                if(invoke(pred, invoke(proj, result), invoke(proj, tmp)))
                    result = (decltype(tmp) &&)tmp;
            }
            return result;
        }

        
         template<typename T, typename C = less, typename P = identity > requires copyable<T> && indirect_strict_weak_order<C, projected<T const *, P>>
#line 73 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"
        constexpr T operator() (std::initializer_list<T> const && rng, C pred = C{}, P proj = P{}) const 
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"
        {
            return (*this)(rng, std::move(pred), std::move(proj));
        }

    } ; inline constexpr max_fn max{};

    namespace cpp20
    {
        using ranges::max;
    }
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"

#line 91 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/max.hpp"
#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"






























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"

namespace ranges
{
    
    
    struct min_fn {

        
         template<typename T, typename C = less, typename P = identity > requires indirect_strict_weak_order<C, projected<T const *, P>>
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"
        constexpr T const & operator() (T const & a, T const & b, C pred = C{}, P proj = P{}) const 
#line 44 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"
        {
            return invoke(pred, invoke(proj, b), invoke(proj, a)) ? b : a;
        }

        
         template<typename Rng, typename C = less, typename P = identity > requires input_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> && indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"
        constexpr range_value_t<Rng> 
        operator() (Rng && rng, C pred = C{}, P proj = P{}) const 
        {
            auto first = ranges::begin(rng);
            auto last = ranges::end(rng);
            static_cast<void>((first != last) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp", 58, "assertion failed: " "first != last"));
            range_value_t<Rng> result = *first;
            while(++first != last)
            {
                auto && tmp = *first;
                if(invoke(pred, invoke(proj, tmp), invoke(proj, result)))
                    result = (decltype(tmp) &&)tmp;
            }
            return result;
        }

        
         template<typename T, typename C = less, typename P = identity > requires copyable<T> && indirect_strict_weak_order<C, projected<T const *, P>>
#line 73 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"
        constexpr T operator() (std::initializer_list<T> const && rng, C pred = C{}, P proj = P{}) const 
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"
        {
            return (*this)(rng, std::move(pred), std::move(proj));
        }

    } ; inline constexpr min_fn min{};

    namespace cpp20
    {
        using ranges::min;
    }
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"

#line 91 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/algorithm/min.hpp"
#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind_back.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind_back.hpp"

namespace ranges
{
    
    
    
    namespace detail
    {
        template<typename Fn, typename... Args>
        struct bind_back_fn_
        {
            using tuple_t = std::tuple<Fn, Args...>;
            tuple_t fn_args_;

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn, CallArgs..., Args...> 
            operator()(CallArgs &&... cargs) &&
                noexcept(is_nothrow_invocable_v<Fn, CallArgs..., Args...>)
            {
                return tuple_apply(
                    [&](auto && fn, auto &&... args) -> decltype(auto) {
                        return invoke((decltype(fn))fn,
                                      (CallArgs &&) cargs...,
                                      (decltype(args))args...);
                    },
                    (std::tuple<Fn, Args...> &&) fn_args_);
            }

            
            template<typename... CallArgs>
            constexpr invoke_result_t<Fn &, CallArgs..., Args &...>
            operator()(CallArgs &&... cargs) &
                noexcept(is_nothrow_invocable_v<Fn &, CallArgs..., Args &...>)
            {
                return tuple_apply(
                    [&](auto & fn, auto &... args) -> decltype(auto) {
                        return invoke(fn, (CallArgs &&) cargs..., args...);
                    },
                    fn_args_);
            }

            
            template<typename... CallArgs>
            constexpr invoke_result_t<Fn const &, CallArgs..., Args const &...>
            operator()(CallArgs &&... cargs) const & 
                noexcept(is_nothrow_invocable_v<Fn const &, CallArgs..., Args const &...>)
            {
                return tuple_apply(
                    [&](auto & fn, auto &... args) -> decltype(auto) {
                        return invoke(fn, (CallArgs &&) cargs..., args...);
                    },
                    fn_args_);
            }
        };

        
        
        template<typename Fn, typename Arg>
        struct bind_back_fn_<Fn, Arg>
        {
            struct tuple_t
            {
                Fn fn_;
                Arg arg_;
            };
            tuple_t fn_args_;

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn, CallArgs..., Arg> 
            operator()(CallArgs &&... cargs) && 
                noexcept(is_nothrow_invocable_v<Fn, CallArgs..., Arg>)
            {
                return invoke(
                    (Fn &&) fn_args_.fn_, (CallArgs &&) cargs..., (Arg &&) fn_args_.arg_);
            }

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn &, CallArgs..., Arg &> 
            operator()(CallArgs &&... cargs) & 
                noexcept(is_nothrow_invocable_v<Fn &, CallArgs..., Arg &>)
            {
                return invoke(fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg_);
            }

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn const &, CallArgs..., Arg const &> 
            operator()(CallArgs &&... cargs) const & 
                noexcept(is_nothrow_invocable_v<Fn const &, CallArgs..., Arg const &>)
            {
                return invoke(fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg_);
            }
        };

        template<typename Fn, typename Arg0, typename Arg1>
        struct bind_back_fn_<Fn, Arg0, Arg1>
        {
            struct tuple_t
            {
                Fn fn_;
                Arg0 arg0_;
                Arg1 arg1_;
            };
            tuple_t fn_args_;

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn, CallArgs..., Arg0, Arg1> 
            operator()(CallArgs &&... cargs) && 
                noexcept(is_nothrow_invocable_v<Fn, CallArgs..., Arg0, Arg1>)
            {
                return invoke((Fn &&) fn_args_.fn_,
                              (CallArgs &&) cargs...,
                              (Arg0 &&) fn_args_.arg0_,
                              (Arg1 &&) fn_args_.arg1_);
            }

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn &, CallArgs..., Arg0 &, Arg1 &> 
            operator()(CallArgs &&... cargs) & 
                noexcept(is_nothrow_invocable_v<Fn &, CallArgs..., Arg0 &, Arg1 &>)
            {
                return invoke(
                    fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg0_, fn_args_.arg1_);
            }

            template<typename... CallArgs>
            constexpr invoke_result_t<Fn const &, CallArgs..., Arg0 const &, Arg1 const &>
            operator()(CallArgs &&... cargs) const & 
                noexcept(is_nothrow_invocable_v<Fn const &,
                                                CallArgs...,
                                                Arg0 const &,
                                                Arg1 const &>)
            {
                return invoke(
                    fn_args_.fn_, (CallArgs &&) cargs..., fn_args_.arg0_, fn_args_.arg1_);
            }
        };
        

        template<typename Fn, typename... Args>
        using bind_back_fn = bind_back_fn_<decay_t<Fn>, decay_t<Args>...>;
    } 

    struct bind_back_fn
    {
        template<typename Fn, typename Arg1, typename... Args>
        constexpr detail::bind_back_fn<Fn, Arg1, Args...> 
        operator()(Fn && fn, Arg1 && arg1, Args &&... args) const
        {



#line 179 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind_back.hpp"
            return {{(Fn &&) fn, (Arg1 &&) arg1, (Args &&) args...}};
#line 181 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind_back.hpp"
        }
    };

    
    
    inline constexpr bind_back_fn bind_back{};

} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 191 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind_back.hpp"

#line 193 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/bind_back.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"

namespace ranges
{
    
    
    template<typename Fn>
    struct indirected
    {
    private:
        
        Fn fn_;

    public:
        indirected() = default;
        indirected(Fn fn)
          : fn_(std::move(fn))
        {}
        
        template<typename... Its>
        [[noreturn]] invoke_result_t<Fn &, iter_reference_t<Its>...> 
        operator()(copy_tag, Its...) const
        {
            static_cast<void>((false) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp", 49, "assertion failed: " "false"));
        }

        
        
        template<typename... Its>
        auto operator() (Its... its) noexcept(noexcept(invoke(fn_, *its...))) -> decltype(invoke(fn_, *its...)) { return (invoke(fn_, *its...)); }
#line 59 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"
        template<typename... Its>
        auto operator() (Its... its) const noexcept(noexcept(invoke((Fn const &)fn_, *its...))) -> decltype(invoke((Fn const &)fn_, *its...)) { return (invoke((Fn const &)fn_, *its...)); }
#line 64 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"

        
        template<typename... Its>
        auto operator() (move_tag, Its... its) noexcept(noexcept(static_cast< aux::move_t<invoke_result_t<Fn &, iter_reference_t<Its>...>>>( aux::move(invoke(fn_, *its...))))) -> decltype(static_cast< aux::move_t<invoke_result_t<Fn &, iter_reference_t<Its>...>>>( aux::move(invoke(fn_, *its...)))) { return (static_cast< aux::move_t<invoke_result_t<Fn &, iter_reference_t<Its>...>>>( aux::move(invoke(fn_, *its...)))); }
#line 73 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"
        template<typename... Its>
        auto operator() (move_tag, Its... its) const noexcept(noexcept(static_cast< aux::move_t<invoke_result_t<Fn const &, iter_reference_t<Its>...>>>( aux::move(invoke((Fn const &)fn_, *its...))))) -> decltype(static_cast< aux::move_t<invoke_result_t<Fn const &, iter_reference_t<Its>...>>>( aux::move(invoke((Fn const &)fn_, *its...)))) { return (static_cast< aux::move_t<invoke_result_t<Fn const &, iter_reference_t<Its>...>>>( aux::move(invoke((Fn const &)fn_, *its...)))); }
#line 80 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"
        
    };

    struct indirect_fn
    {
        template<typename Fn>
        constexpr indirected<Fn> operator()(Fn fn) const
        {
            return indirected<Fn>{detail::move(fn)};
        }
    };

    
    
    inline constexpr indirect_fn indirect{};
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 99 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"

#line 101 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/functional/indirect.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"

namespace ranges
{
    
    

    
    template<typename I>
        
    struct counted_iterator;
    

    struct advance_fn
    {

         template<typename I > requires input_or_output_iterator<I>
#line 43 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr void operator()(I & i, iter_difference_t<I> n) const
        
        {
            if constexpr(random_access_iterator<I>)
            {
                i += n;
            }
            else
            {
                if constexpr(bidirectional_iterator<I>)
                    for(; 0 > n; ++n)
                        --i;
                static_cast<void>((0 <= n) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 55, "assertion failed: " "0 <= n"));
                for(; 0 < n; --n)
                    ++i;
            }
        }

         template<typename I, typename S > requires sentinel_for<S, I>
#line 63 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr void operator()(I & i, S bound) const
        
        {
            if constexpr(assignable_from<I &, S>)
            {
                i = std::move(bound);
            }
            else if constexpr(sized_sentinel_for<S, I>)
            {
                iter_difference_t<I> d = bound - i;
                static_cast<void>((0 <= d) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 73, "assertion failed: " "0 <= d"));
                (*this)(i, d);
            }
            else
                while(i != bound)
                    ++i;
        }

         template<typename I, typename S > requires sentinel_for<S, I>
#line 83 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr iter_difference_t<I> 
        operator()(I & i, iter_difference_t<I> n, S bound) const
        
        
        
        
        {
            if constexpr(sized_sentinel_for<S, I>)
            {
                if(0 == n)
                    return 0;
                const auto d = bound - i;
                if constexpr(bidirectional_iterator<I> && same_as<I, S>)
                {
                    static_cast<void>((0 <= n ? 0 <= d : 0 >= d) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 97, "assertion failed: " "0 <= n ? 0 <= d : 0 >= d"));
                    if(0 <= n ? d <= n : d >= n)
                    {
                        i = std::move(bound);
                        return n - d;
                    }
                }
                else
                {
                    static_cast<void>((0 <= n && 0 <= d) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 106, "assertion failed: " "0 <= n && 0 <= d"));
                    if(d <= n)
                    {
                        (*this)(i, std::move(bound));
                        return n - d;
                    }
                }
                (*this)(i, n);
                return 0;
            }
            else
            {
                if constexpr(bidirectional_iterator<I> && same_as<I, S>)
                {
                    if(0 > n)
                    {
                        do
                        {
                            --i;
                            ++n;
                        } while(0 != n && i != bound);
                        return n;
                    }
                }
                static_cast<void>((0 <= n) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 130, "assertion failed: " "0 <= n"));
                while(0 != n && i != bound)
                {
                    ++i;
                    --n;
                }
                return n;
            }
        }



























































#line 199 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"

         template<typename I > requires input_or_output_iterator<I>
#line 202 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr void operator()(counted_iterator<I> & i, iter_difference_t<I> n) const;
    };

    
    inline constexpr advance_fn advance{};



























































































#line 299 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"

    struct next_fn
    {
         template<typename I > requires input_or_output_iterator<I>
#line 304 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it) const
        {
            return ++it;
        }
         template<typename I > requires input_or_output_iterator<I>
#line 310 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it, iter_difference_t<I> n) const
        {
            advance(it, n);
            return it;
        }
         template<typename I, typename S > requires sentinel_for<S, I>
#line 317 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it, S s) const
        {
            advance(it, static_cast<S &&>(s));
            return it;
        }
         template<typename I, typename S > requires sentinel_for<S, I>
#line 324 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it, iter_difference_t<I> n, S bound) const
        {
            advance(it, n, static_cast<S &&>(bound));
            return it;
        }
    };

    
    inline constexpr next_fn next{};

    struct prev_fn
    {
         template<typename I > requires bidirectional_iterator<I>
#line 338 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it) const
        {
            return --it;
        }
         template<typename I > requires bidirectional_iterator<I>
#line 344 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it, iter_difference_t<I> n) const
        {
            advance(it, -n);
            return it;
        }
         template<typename I > requires bidirectional_iterator<I>
#line 351 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr I operator()(I it, iter_difference_t<I> n, I bound) const
        {
            advance(it, -n, static_cast<I &&>(bound));
            return it;
        }
    };

    
    inline constexpr prev_fn prev{};

    struct iter_enumerate_fn
    {
    private:
         template<typename I, typename S > requires (!sized_sentinel_for<I, I>) 
#line 366 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        static constexpr std::pair<iter_difference_t<I>, I> 
        impl_i(I first, S last, sentinel_tag)
        {
            iter_difference_t<I> d = 0;
            for(; first != last; ++first)
                ++d;
            return {d, first};
        }
         template<typename I, typename S > requires sized_sentinel_for<I, I>
#line 376 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        static constexpr std::pair<iter_difference_t<I>, I> 
        impl_i(I first, S end_, sentinel_tag)
        {
            I last = ranges::next(first, end_);
            auto n = static_cast<iter_difference_t<I>>(last - first);
            static_cast<void>((((bool)same_as<I, S> || 0 <= n)) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 381, "assertion failed: " "((bool)same_as<I, S> || 0 <= n)"));
            return {n, last};
        }
        template<typename I, typename S>
        static constexpr std::pair<iter_difference_t<I>, I> 
        impl_i(I first, S last, sized_sentinel_tag)
        {
            auto n = static_cast<iter_difference_t<I>>(last - first);
            static_cast<void>((((bool)same_as<I, S> || 0 <= n)) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 389, "assertion failed: " "((bool)same_as<I, S> || 0 <= n)"));
            return {n, ranges::next(first, last)};
        }

    public:
         template<typename I, typename S > requires sentinel_for<S, I>
#line 396 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr std::pair<iter_difference_t<I>, I> operator()(I first, S last) const
        {
            return iter_enumerate_fn::impl_i(static_cast<I &&>(first),
                                             static_cast<S &&>(last),
                                             sentinel_tag_of<S, I>());
        }
    };

    
    inline constexpr iter_enumerate_fn iter_enumerate{};

    struct iter_distance_fn
    {
    private:
        template<typename I, typename S>
        static constexpr iter_difference_t<I> impl_i(I first, S last, sentinel_tag)
        {
            return iter_enumerate(static_cast<I &&>(first), static_cast<S &&>(last))
                .first;
        }
        template<typename I, typename S>
        static constexpr iter_difference_t<I> impl_i(I first, S last, sized_sentinel_tag)
        {
            auto n = static_cast<iter_difference_t<I>>(last - first);
            static_cast<void>((((bool)same_as<I, S> || 0 <= n)) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 420, "assertion failed: " "((bool)same_as<I, S> || 0 <= n)"));
            return n;
        }

    public:
         template<typename I, typename S > requires input_or_output_iterator<I> && sentinel_for<S, I>
#line 427 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr iter_difference_t<I> operator()(I first, S last) const
        {
            return iter_distance_fn::impl_i(static_cast<I &&>(first),
                                            static_cast<S &&>(last),
                                            sentinel_tag_of<S, I>());
        }
    };

    
    inline constexpr iter_distance_fn iter_distance{};

    struct iter_distance_compare_fn
    {
    private:
        template<typename I, typename S>
        static constexpr int impl_i(I first, S last, iter_difference_t<I> n, sentinel_tag)
        {
            if(n < 0)
                return 1;
            for(; n > 0; --n, ++first)
            {
                if(first == last)
                    return -1;
            }
            return first == last ? 0 : 1;
        }
        template<typename I, typename S>
        static constexpr int impl_i(I first, S last, iter_difference_t<I> n,
                                    sized_sentinel_tag)
        {
            iter_difference_t<I> dist = last - first;
            if(n < dist)
                return 1;
            if(dist < n)
                return -1;
            return 0;
        }

    public:
         template<typename I, typename S > requires input_iterator<I> && sentinel_for<S, I>
#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr int operator()(I first, S last, iter_difference_t<I> n) const
        {
            return iter_distance_compare_fn::impl_i(static_cast<I &&>(first),
                                                    static_cast<S &&>(last),
                                                    n,
                                                    sentinel_tag_of<S, I>());
        }
    };

    
    inline constexpr iter_distance_compare_fn iter_distance_compare{};

    
    struct iter_size_fn
    {
         template<typename I, typename S > requires sized_sentinel_for<S, I>
#line 485 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr meta::_t<std::make_unsigned<iter_difference_t<I>>> 
        operator()(I const & first, S last) const
        {
            using size_type = meta::_t<std::make_unsigned<iter_difference_t<I>>>;
            iter_difference_t<I> n = last - first;
            static_cast<void>((0 <= n) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 490, "assertion failed: " "0 <= n"));
            return static_cast<size_type>(n);
        }
    };

    
    inline constexpr iter_size_fn iter_size{};

    
    namespace adl_uncounted_recounted_detail
    {
        template<typename I>
        constexpr I uncounted(I i)
        {
            return i;
        }

        template<typename I>
        constexpr I recounted(I const &, I i, iter_difference_t<I>)
        {
            return i;
        }

        struct uncounted_fn
        {
            template<typename I>
            constexpr auto operator()(I i) const -> decltype(uncounted((I &&) i))
            {
                return uncounted((I &&) i);
            }
        };

        struct recounted_fn
        {
            template<typename I, typename J>
            constexpr auto operator()(I i, J j, iter_difference_t<J> n) const
                -> decltype(recounted((I &&) i, (J &&) j, n))
            {
                return recounted((I &&) i, (J &&) j, n);
            }
        };
    } 
    

    inline constexpr adl_uncounted_recounted_detail::uncounted_fn uncounted{};
    inline constexpr adl_uncounted_recounted_detail::recounted_fn recounted{};

    struct enumerate_fn : iter_enumerate_fn
    {
    private:
        template<typename Rng>
        static constexpr std::pair<range_difference_t<Rng>, iterator_t<Rng>> impl_r(
            Rng & rng, range_tag, range_tag)
        {
            return iter_enumerate(begin(rng), end(rng));
        }
        template<typename Rng>
        static constexpr std::pair<range_difference_t<Rng>, iterator_t<Rng>> impl_r(
            Rng & rng, common_range_tag, sized_range_tag)
        {
            return {static_cast<range_difference_t<Rng>>(size(rng)), end(rng)};
        }

    public:
        using iter_enumerate_fn::operator();

         template<typename Rng > requires range<Rng>
#line 558 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr std::pair<range_difference_t<Rng>, iterator_t<Rng>> operator()(Rng && rng) const
        {
            
            static_cast<void>((!is_infinite<Rng>::value) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 561, "assertion failed: " "!is_infinite<Rng>::value"));
            return enumerate_fn::impl_r(
                rng, common_range_tag_of<Rng>(), sized_range_tag_of<Rng>());
        }
    };

    
    inline constexpr enumerate_fn enumerate{};

    struct distance_fn : iter_distance_fn
    {
    private:
        template<typename Rng>
        static range_difference_t<Rng> impl_r(Rng & rng, range_tag)
        {
            return enumerate(rng).first;
        }
        template<typename Rng>
        static constexpr range_difference_t<Rng> impl_r(Rng & rng, sized_range_tag)
        {
            return static_cast<range_difference_t<Rng>>(size(rng));
        }

    public:
        using iter_distance_fn::operator();

         template<typename Rng > requires range<Rng>
#line 589 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr range_difference_t<Rng> operator()(Rng && rng) const
        {
            
            static_cast<void>((!is_infinite<Rng>::value) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp", 592, "assertion failed: " "!is_infinite<Rng>::value"));
            return distance_fn::impl_r(rng, sized_range_tag_of<Rng>());
        }
    };

    
    inline constexpr distance_fn distance{};

    
    struct distance_compare_fn : iter_distance_compare_fn
    {
    private:
        template<typename Rng>
        static constexpr int impl_r(Rng & rng, range_difference_t<Rng> n, range_tag)
        {
            
            return is_infinite<Rng>::value
                       ? 1
                       : iter_distance_compare(begin(rng), end(rng), n);
        }
        template<typename Rng>
        static constexpr int impl_r(Rng & rng, range_difference_t<Rng> n, sized_range_tag)
        {
            auto dist = distance(rng); 
            if(dist > n)
                return 1;
            else if(dist < n)
                return -1;
            else
                return 0;
        }

    public:
        using iter_distance_compare_fn::operator();

         template<typename Rng > requires range<Rng>
#line 629 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
        constexpr int operator()(Rng && rng, range_difference_t<Rng> n) const
        {
            return distance_compare_fn::impl_r(rng, n, sized_range_tag_of<Rng>());
        }
    };

    
    inline constexpr distance_compare_fn distance_compare{};

    namespace cpp20
    {
        using ranges::advance;
        using ranges::distance;
        using ranges::next;
        using ranges::prev;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 649 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"

#line 651 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/operations.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"






#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"





























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"

namespace ranges
{
    
    namespace compressed_tuple_detail
    {
        
        
        template<typename T, std::size_t I, typename... Ts>
        using storage = box<T, meta::list<meta::size_t<I>, Ts...>>;

        template<typename List, typename Indices>
        struct compressed_tuple_;
        template<typename... Ts, std::size_t... Is>
        struct __declspec(empty_bases)
            compressed_tuple_<meta::list<Ts...>, meta::index_sequence<Is...>>
          : storage<Ts, Is, Ts...>...
        {
            static_assert(same_as<meta::index_sequence<Is...>,
                                  meta::make_index_sequence<sizeof...(Is)>>,
                          "What madness is this?!?");

            compressed_tuple_() = default;

            template<typename... Args,
                     meta::if_<meta::and_c<__is_constructible(Ts, Args)...>, int> = 0>
            constexpr compressed_tuple_(Args &&... args) noexcept(
                meta::strict_and<std::is_nothrow_constructible<storage<Ts, Is, Ts...>,
                                                               Args>...>::value)
              : storage<Ts, Is, Ts...>{static_cast<Args &&>(args)}...
            {}

            template<
                typename... Us,
                meta::if_<meta::and_c<__is_constructible(Us, Ts const &)...>, int> = 0>
            constexpr operator std::tuple<Us...>() const noexcept(
                meta::strict_and<std::is_nothrow_constructible<Us, Ts const &>...>::value)
            {
                return std::tuple<Us...>{get<Is>(*this)...};
            }

            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
            friend constexpr T & get(compressed_tuple_ & tuple) noexcept
            {
                return static_cast<storage<T, I, Ts...> &>(tuple).get();
            }
            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
            friend constexpr T const & get(compressed_tuple_ const & tuple) noexcept
            {
                return static_cast<storage<T, I, Ts...> const &>(tuple).get();
            }
            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
            friend constexpr T && get(compressed_tuple_ && tuple) noexcept
            {
                return static_cast<storage<T, I, Ts...> &&>(tuple).get();
            }
            template<std::size_t I, typename T = meta::at_c<meta::list<Ts...>, I>>
            friend constexpr T const && get(compressed_tuple_ const && tuple) noexcept
            {
                return static_cast<storage<T, I, Ts...> const &&>(tuple).get();
            }
        };

        template<typename... Ts>
        using compressed_tuple [[deprecated("ranges::compressed_tuple is deprecated.")]] =
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"
            compressed_tuple_<meta::list<Ts...>,
                              meta::make_index_sequence<sizeof...(Ts)>>;
    } 
    

    using compressed_tuple_detail::compressed_tuple;

    struct make_compressed_tuple_fn
    {
        
        template<typename... Args>
        constexpr auto operator() (Args &&... args) const noexcept(noexcept(compressed_tuple<bind_element_t<Args>...>{ static_cast<Args &&>(args)...})) -> decltype(compressed_tuple<bind_element_t<Args>...>{ static_cast<Args &&>(args)...}) { return (compressed_tuple<bind_element_t<Args>...>{ static_cast<Args &&>(args)...}); }
#line 113 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"
        
    };

    
    
    inline constexpr make_compressed_tuple_fn make_compressed_tuple{};

    template<typename First, typename Second>
    struct __declspec(empty_bases) compressed_pair
      : box<First, meta::size_t<0>>
      , box<Second, meta::size_t<1>>
    {
        using first_type = First;
        using second_type = Second;

        compressed_pair() = default;

         template<typename U, typename V > requires constructible_from<First, U> && constructible_from<Second, V>
#line 132 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"
        constexpr compressed_pair(U && u, V && v) 
            noexcept(noexcept(First((U &&) u)) && noexcept(Second((V &&) v)))
          : box<First, meta::size_t<0>>{(U &&) u}
          , box<Second, meta::size_t<1>>{(V &&) v}
        {}

        constexpr First & first() &
        {
            return this->box<First, meta::size_t<0>>::get();
        }
        constexpr First const & first() const &
        {
            return this->box<First, meta::size_t<0>>::get();
        }
        constexpr First && first() &&
        {
            return static_cast<First &&>(this->box<First, meta::size_t<0>>::get());
        }

        constexpr Second & second() &
        {
            return this->box<Second, meta::size_t<1>>::get();
        }
        constexpr Second const & second() const &
        {
            return this->box<Second, meta::size_t<1>>::get();
        }
        constexpr Second && second() &&
        {
            return static_cast<Second &&>(this->box<Second, meta::size_t<1>>::get());
        }

         template<typename F, typename S > requires convertible_to<First const &, F> && convertible_to<Second const &, S>
#line 167 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"
            constexpr
            operator std::pair<F, S>() const
        {
            return std::pair<F, S>{first(), second()};
        }
    };

    struct make_compressed_pair_fn
    {
        
        template<typename First, typename Second>
        constexpr auto operator() (First &&f, Second &&s) const noexcept(noexcept(compressed_pair<bind_element_t<First>, bind_element_t<Second>>{ static_cast<First &&>(f), static_cast<Second &&>(s) })) -> decltype(compressed_pair<bind_element_t<First>, bind_element_t<Second>>{ static_cast<First &&>(f), static_cast<Second &&>(s) }) { return (compressed_pair<bind_element_t<First>, bind_element_t<Second>>{ static_cast<First &&>(f), static_cast<Second &&>(s) }); }
#line 184 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"
        
    };

    
    
    inline constexpr make_compressed_pair_fn make_compressed_pair{};
} 

__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))
namespace std
{
    template<typename... Ts, size_t... Is>
    struct tuple_size<::ranges::compressed_tuple_detail::compressed_tuple_<
        ::meta::list<Ts...>, ::meta::index_sequence<Is...>>>
      : integral_constant<size_t, sizeof...(Ts)>
    {};

    template<size_t I, typename... Ts, size_t... Is>
    struct tuple_element<I, ::ranges::compressed_tuple_detail::compressed_tuple_<
                                ::meta::list<Ts...>, ::meta::index_sequence<Is...>>>
    {
        using type = ::meta::at_c<::meta::list<Ts...>, I>;
    };

    template<typename First, typename Second>
    struct tuple_size<::ranges::compressed_pair<First, Second>>
      : integral_constant<size_t, 2>
    {};

    template<typename First, typename Second>
    struct tuple_element<0, ::ranges::compressed_pair<First, Second>>
    {
        using type = First;
    };

    template<typename First, typename Second>
    struct tuple_element<1, ::ranges::compressed_pair<First, Second>>
    {
        using type = Second;
    };
} 
__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 229 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"

#line 231 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/utility/compressed_pair.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"






























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"



#line 36 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"

#line 38 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename From, typename To = From>
        struct slice_bounds
        {
            From from;
            To to;
             template<typename F, typename T > requires convertible_to<F, From> && convertible_to<T, To>
#line 51 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
            constexpr slice_bounds(F f, T t)
              : from(static_cast<From>(f))
              , to(static_cast<To>(t))
            {}
        };

        template<typename Int>
        struct from_end_
        {
            Int dist_;

            constexpr explicit from_end_(Int dist)
              : dist_(dist)
            {}

             template<typename Other > requires integer_like_<Other> && explicitly_convertible_to<Other, Int>
#line 68 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
            constexpr operator from_end_<Other>() const
            {
                return from_end_<Other>{static_cast<Other>(dist_)};
            }
        };

        template<typename Rng>
        using from_end_of_t = from_end_<range_difference_t<Rng>>;

        
        
        
        template<typename Rng>
        concept _can_empty_requires_ = requires(Rng & rng) { ranges::empty(rng); };
#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        
        
        template<typename Rng>
        concept can_empty_ = 
            detail::_can_empty_requires_<Rng>;
        

        template<cardinality C>
        inline constexpr bool has_fixed_size_ = (C >= 0 || C == infinite);

        template<bool>
        struct dependent_
        {
            template<typename T>
            using invoke = T;
        };

        template<typename Stream, typename Rng>
        Stream & print_rng_(Stream & sout, Rng & rng)
        {
            sout << '[';
            auto it = ranges::begin(rng);
            auto const e = ranges::end(rng);
            if(it != e)
            {
                for(;;)
                {
                    sout << *it;
                    if(++it == e)
                        break;
                    sout << ',';
                }
            }
            sout << ']';
            return sout;
        }
    } 
    

    
    
    template<typename Derived, cardinality Cardinality >
    struct view_interface : basic_view<Cardinality>
    {
    protected:
        template<bool B>
        using D = meta::invoke<detail::dependent_<B>, Derived>;

        constexpr Derived & derived() noexcept
        {
            static_assert(static_cast<bool>(derived_from<Derived, view_interface>), "Concept assertion failed : " "derived_from<Derived, view_interface>");
            return static_cast<Derived &>(*this);
        }
        
        constexpr Derived const & derived() const noexcept
        {
            static_assert(static_cast<bool>(derived_from<Derived, view_interface>), "Concept assertion failed : " "derived_from<Derived, view_interface>");
            return static_cast<Derived const &>(*this);
        }

    public:
        view_interface() = default;
        view_interface(view_interface &&) = default;
        view_interface(view_interface const &) = default;
        view_interface & operator=(view_interface &&) = default;
        view_interface & operator=(view_interface const &) = default;
        
        
        constexpr auto empty() const noexcept 
            -> bool requires (detail::has_fixed_size_<Cardinality>)
#line 157 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        {
            return Cardinality == 0;
        }
        
         template<bool True = true > requires True && (Cardinality < 0) && (Cardinality != infinite) && (!forward_range<D<True>>) && sized_range<D<True>>
#line 164 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr bool empty() 
            noexcept(noexcept(bool(ranges::size(std::declval<D<True> &>()) == 0)))
        {
            return ranges::size(derived()) == 0;
        }
        
         template<bool True = true > requires True && (Cardinality < 0) && (Cardinality != infinite) && (!forward_range<D<True> const>) && sized_range<D<True> const>
#line 173 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr bool empty() const 
            noexcept(noexcept(bool(ranges::size(std::declval<D<True> const &>()) == 0)))
        {
            return ranges::size(derived()) == 0;
        }
        
         template<bool True = true > requires True && (!detail::has_fixed_size_<Cardinality>) && forward_range<D<True>>
#line 182 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr bool empty() noexcept(
            noexcept(bool(ranges::begin(std::declval<D<True> &>()) ==
                          ranges::end(std::declval<D<True> &>()))))
        {
            return bool(ranges::begin(derived()) == ranges::end(derived()));
        }
        
         template<bool True = true > requires True && (!detail::has_fixed_size_<Cardinality>) && forward_range<D<True> const>
#line 192 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr bool empty() const
            noexcept(noexcept(bool(ranges::begin(std::declval<D<True> const &>()) ==
                                   ranges::end(std::declval<D<True> const &>()))))
        {
            return bool(ranges::begin(derived()) == ranges::end(derived()));
        }
         template<bool True = true > requires True && detail::can_empty_<D<True>> 
#line 200 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr explicit operator bool()
            noexcept(noexcept(ranges::empty(std::declval<D<True> &>())))
        {
            return !ranges::empty(derived());
        }
        
        
         template<bool True = true > requires True && detail::can_empty_<D<True> const> 
#line 209 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr explicit operator bool() const
            noexcept(noexcept(ranges::empty(std::declval<D<True> const &>())))
        {
            return !ranges::empty(derived());
        }
        
        
        
         template<bool True = true, int = 42 > requires True && (Cardinality >= 0) 
#line 219 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        static constexpr std::size_t size() noexcept
        {
            return static_cast<std::size_t>(Cardinality);
        }
        
        
        
         template<bool True = true > requires True && (Cardinality < 0) && sized_sentinel_for<sentinel_t<D<True>>, iterator_t<D<True>>> && forward_range<D<True>>
#line 230 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr detail::iter_size_t<iterator_t<D<True>>> size()
        {
            using size_type = detail::iter_size_t<iterator_t<D<True>>>;
            return static_cast<size_type>(derived().end() - derived().begin());
        }
        
         template<bool True = true > requires True && (Cardinality < 0) && sized_sentinel_for<sentinel_t<D<True> const>, iterator_t<D<True> const>> && forward_range<D<True> const>
#line 241 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr detail::iter_size_t<iterator_t<D<True>>> size() const 
        {
            using size_type = detail::iter_size_t<iterator_t<D<True>>>;
            return static_cast<size_type>(derived().end() - derived().begin());
        }
        
         template<bool True = true > requires True && forward_range<D<True>>
#line 249 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True>> front()
        {
            return *derived().begin();
        }
        
         template<bool True = true > requires True && forward_range<D<True> const>
#line 256 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True> const> front() const
        {
            return *derived().begin();
        }
        
         template<bool True = true > requires True && common_range<D<True>> && bidirectional_range<D<True>>
#line 263 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True>> back()
        {
            return *prev(derived().end());
        }
        
         template<bool True = true > requires True && common_range<D<True> const> && bidirectional_range<D<True> const>
#line 271 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True> const> back() const
        {
            return *prev(derived().end());
        }
        
         template<bool True = true > requires True && random_access_range<D<True>>
#line 278 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True>> operator[](range_difference_t<D<True>> n)
        {
            return derived().begin()[n];
        }
        
         template<bool True = true > requires True && random_access_range<D<True> const>
#line 285 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True> const> 
        operator[](range_difference_t<D<True>> n) const
        {
            return derived().begin()[n];
        }
        
        
         template<bool True = true > requires True && contiguous_iterator<iterator_t<D<True>>>
#line 294 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr std::add_pointer_t<range_reference_t<D<True>>> data() 
        {
            return std::addressof(*ranges::begin(derived()));
        }
        
         template<bool True = true > requires True && contiguous_iterator<iterator_t<D<True> const>>
#line 301 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr std::add_pointer_t<range_reference_t<D<True> const>> data() const 
        {
            return std::addressof(*ranges::begin(derived()));
        }
        
        
         template<bool True = true > requires True && random_access_range<D<True>> && sized_range<D<True>>
#line 309 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True>> at(range_difference_t<D<True>> n)
        {
            using size_type = range_size_t<Derived>;
            if(n < 0 || size_type(n) >= ranges::size(derived()))
            {
                throw std::out_of_range("view_interface::at");
            }
            return derived().begin()[n];
        }
        
         template<bool True = true > requires True && random_access_range<D<True> const> && sized_range<D<True> const>
#line 322 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr range_reference_t<D<True> const> at(range_difference_t<D<True>> n) const
        {
            using size_type = range_size_t<Derived const>;
            if(n < 0 || size_type(n) >= ranges::size(derived()))
            {
                throw std::out_of_range("view_interface::at");
            }
            return derived().begin()[n];
        }
        
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True> &>
#line 335 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto
            operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True> const &>
#line 343 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto
            operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) const &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True>>
#line 351 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto
            operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) &&
        {
            return Slice{}(detail::move(derived()), offs.from, offs.to);
        }
        
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True> &> && sized_range<D<True> &>
#line 360 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<range_difference_t<D<True>>,
                                        detail::from_end_of_t<D<True>>> offs) &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True> const &> && sized_range<D<True> const &>
#line 370 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<range_difference_t<D<True>>,
                                        detail::from_end_of_t<D<True>>> offs) const &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True>> && sized_range<D<True>>
#line 379 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<range_difference_t<D<True>>,
                                        detail::from_end_of_t<D<True>>> offs) &&
        {
            return Slice{}(detail::move(derived()), offs.from, offs.to);
        }
        
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && (forward_range<D<True> &> || (input_range<D<True> &> && sized_range<D<True> &>)) 
#line 390 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
                                        detail::from_end_of_t<D<True>>> offs) &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && (forward_range<D<True> const &> || (input_range<D<True> const &> && sized_range<D<True> const &>)) 
#line 401 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
                                        detail::from_end_of_t<D<True>>> offs) const &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && (forward_range<D<True>> || (input_range<D<True>> && sized_range<D<True>>)) 
#line 412 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
                                        detail::from_end_of_t<D<True>>> offs) &&
        {
            return Slice{}(detail::move(derived()), offs.from, offs.to);
        }
        
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True> &>
#line 422 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True> const &>
#line 430 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) const &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && input_range<D<True>>
#line 438 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) &&
        {
            return Slice{}(detail::move(derived()), offs.from, offs.to);
        }
        
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && (forward_range<D<True> &> || (input_range<D<True> &> && sized_range<D<True> &>)) 
#line 449 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && (forward_range<D<True> const &> || (input_range<D<True> const &> && sized_range<D<True> const &>)) 
#line 459 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](
            detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) const &
        {
            return Slice{}(derived(), offs.from, offs.to);
        }
        
         template<bool True = true, typename Slice = views::slice_fn > requires True && (forward_range<D<True>> || (input_range<D<True>> && sized_range<D<True>>)) 
#line 470 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        constexpr auto 
        operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) &&
        {
            return Slice{}(detail::move(derived()), offs.from, offs.to);
        }
    private:

        
        template<bool True = true>
        friend auto operator<<(std::ostream & sout, Derived const & rng)
            -> ::concepts::return_t< std::ostream &, std::enable_if_t<( True && input_range<D<True> const> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 482 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        {
            return detail::print_rng_(sout, rng);
        }
        
        template<bool True = true>
        friend auto operator<<(std::ostream & sout, Derived & rng)
            -> ::concepts::return_t< std::ostream &, std::enable_if_t<( True && (!range<D<True> const>) && input_range<D<True>> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 490 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        {
            return detail::print_rng_(sout, rng);
        }
        
        template<bool True = true>
        friend auto operator<<(std::ostream & sout, Derived && rng)
            -> ::concepts::return_t< std::ostream &, std::enable_if_t<( True && (!range<D<True> const>) && input_range<D<True>> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 498 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        {
            return detail::print_rng_(sout, rng);
        }
#line 502 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
    };
    namespace cpp20
    {
         template<typename Derived > requires std::is_class<Derived>::value && same_as<Derived, meta::_t<std::remove_cv<Derived>>>
#line 508 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
        using view_interface = ranges::view_interface<Derived, ranges::unknown>;
    }
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 514 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"

#line 516 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/interface.hpp"
#pragma external_header(pop)
#line 26 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"

namespace ranges
{
    template<typename Rng>
    struct ref_view;

    template<typename Rng>
    inline constexpr bool enable_borrowed_range<ref_view<Rng>> = true;

    
    
    template<typename Rng>
    struct ref_view : view_interface<ref_view<Rng>, range_cardinality<Rng>::value>
    {
    private:
        static_assert(static_cast<bool>(range<Rng>), "Concept assertion failed : " "range<Rng>");
        static_assert(std::is_object<Rng>::value, "");
        Rng * rng_ = nullptr; 
    public:
        constexpr ref_view() noexcept = default;
        constexpr ref_view(Rng & rng) noexcept
          : rng_(detail::addressof(rng))
        {}
        constexpr Rng & base() const noexcept
        {
            return *rng_;
        }
        constexpr iterator_t<Rng> begin() const noexcept(noexcept(ranges::begin(*rng_)))
        {
            return ranges::begin(*rng_);
        }
        constexpr sentinel_t<Rng> end() const noexcept(noexcept(ranges::end(*rng_)))
        {
            return ranges::end(*rng_);
        }
        
        constexpr auto empty() const noexcept(noexcept(ranges::empty(*rng_)))
            -> bool requires detail::can_empty_<Rng>
#line 67 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
        {
            return ranges::empty(*rng_);
        }
        
        constexpr auto size () const noexcept(noexcept(ranges::size(*rng_))) requires sized_range<Rng>
#line 74 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
        {
            return ranges::size(*rng_);
        }
        
        constexpr auto data () const noexcept(noexcept(ranges::data(*rng_))) requires contiguous_range<Rng>
#line 81 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
        {
            return ranges::data(*rng_);
        }
    };


     template<typename R > requires range<R>
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
    ref_view(R &) 
        -> ref_view<R>;
#line 92 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"

    namespace views
    {
        struct ref_fn
        {
             template<typename Rng > requires range<Rng>
#line 99 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
            constexpr ref_view<Rng> operator()(Rng & rng) const noexcept
            {
                return ref_view<Rng>(rng);
            }
            template<typename Rng>
            void operator()(Rng const && rng) const = delete;
        };

        
        
        inline constexpr ref_fn ref{};
    } 

    namespace cpp20
    {
         template<typename Rng > requires std::is_object<Rng>::value 
#line 116 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
            using ref_view = ranges::ref_view<Rng>;
    }
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/satisfy_boost_range.hpp"























namespace boost
{
    
    
    template<typename T, typename U>
    struct range_mutable_iterator;

    
    
    template<typename T, typename U>
    struct range_const_iterator;

    
    
    template<typename T>
    struct range_value;

    
    
    template<typename T>
    struct range_size;
} 







































#line 86 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/satisfy_boost_range.hpp"

#line 88 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/satisfy_boost_range.hpp"
#pragma external_header(pop)
#line 121 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
namespace boost { template<typename... Ts> struct range_mutable_iterator< ::ranges::ref_view<Ts...>, ::meta::if_c<(bool)::ranges::common_range<::ranges::ref_view<Ts...>>>> { using type = ::ranges::iterator_t<::ranges::ref_view<Ts...>>; }; template<typename... Ts> struct range_const_iterator< ::ranges::ref_view<Ts...>, ::meta::if_c<(bool)::ranges::common_range<::ranges::ref_view<Ts...> const>>> { using type = ::ranges::iterator_t<::ranges::ref_view<Ts...> const>; }; template<typename... Ts> struct range_value<::ranges::ref_view<Ts...>> { using type = ::ranges::range_value_t<::ranges::ref_view<Ts...>>; }; template<typename... Ts> struct range_size<::ranges::ref_view<Ts...>> : ::meta::if_c<(bool)::ranges::common_range<::ranges::ref_view<Ts...>>, ::meta::defer<::ranges::range_size_t, ::ranges::ref_view<Ts...>>, ::meta::nil_> {}; template<typename... Ts> struct range_size<::ranges::ref_view<Ts...> const> : ::meta::if_c<(bool)::ranges::common_range<::ranges::ref_view<Ts...> const>, ::meta::defer<::ranges::range_size_t, ::ranges::ref_view<Ts...> const>, ::meta::nil_> {}; }

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 124 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"

#line 126 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/ref.hpp"
#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"



















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 21 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"

namespace ranges
{
    
    
    struct unreachable_sentinel_t
    {
        template<typename I>
        friend constexpr auto operator==(I const &, unreachable_sentinel_t) noexcept
            -> ::concepts::return_t< bool, std::enable_if_t<( weakly_incrementable<I> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"
        {
            return false;
        }
        template<typename I>
        friend constexpr auto operator==(unreachable_sentinel_t, I const &) noexcept
            -> ::concepts::return_t< bool, std::enable_if_t<( weakly_incrementable<I> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 39 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"
        {
            return false;
        }
        template<typename I>
        friend constexpr auto operator!=(I const &, unreachable_sentinel_t) noexcept
            -> ::concepts::return_t< bool, std::enable_if_t<( weakly_incrementable<I> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 46 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"
        {
            return true;
        }
        template<typename I>
        friend constexpr auto operator!=(unreachable_sentinel_t, I const &) noexcept
            -> ::concepts::return_t< bool, std::enable_if_t<( weakly_incrementable<I> && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 53 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"
        {
            return true;
        }
    };

    inline constexpr unreachable_sentinel_t unreachable{};

    namespace cpp20
    {
        using ranges::unreachable;
        using ranges::unreachable_sentinel_t;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 69 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"

#line 71 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/unreachable_sentinel.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"


#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"


























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"

namespace ranges
{
    
    
    
    struct dangling
    {
        dangling() = default;
        
         template<typename T > requires not_same_as_<T, dangling>
#line 40 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"
        constexpr dangling(T &&)
        {}
    };

    
    namespace detail
    {
         template<class R, class U > requires range<R>
#line 49 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"
            using maybe_dangling_ =     
                meta::conditional_t<detail::_borrowed_range<R>, U, dangling>;
    }
    

    template<typename Rng>
    using borrowed_iterator_t = detail::maybe_dangling_<Rng, iterator_t<Rng>>;

    template<typename Rng>
    using safe_iterator_t [[deprecated("Please use ranges::borrowed_iterator_t instead.")]] = borrowed_iterator_t<Rng>;
#line 60 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"

    
    struct _sanitize_fn
    {
        template<typename T>
        constexpr T && operator()(T && t) const noexcept
        {
            return static_cast<T &&>(t);
        }
    };

    using sanitize_fn [[deprecated("The sanitize function is unneeded and deprecated.")]] = _sanitize_fn;
#line 73 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"

    namespace
    {
        [[deprecated("The sanitize function is unneeded and deprecated.")]]
        constexpr auto & sanitize = static_const<_sanitize_fn>::value;
    } 
    

    namespace cpp20
    {
        using ranges::dangling;
        using ranges::borrowed_iterator_t;

        template<typename Rng>
        using safe_iterator_t [[deprecated("Please use ranges::borrowed_iterator_t instead.")]] = borrowed_iterator_t<Rng>;
#line 89 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"
    } 
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 93 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"

#line 95 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/range/dangling.hpp"
#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 35 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

namespace ranges
{
    
    
    enum class subrange_kind : bool
    {
        unsized,
        sized
    };

    
    namespace detail
    {
        
        
        
        template<typename From, typename To>
        concept convertible_to_not_slicing_ =
            convertible_to<From, To> &&
            
            
            
            (!(std::is_pointer<decay_t<From>>::value &&
                std::is_pointer<decay_t<To>>::value &&
                not_same_as_<std::remove_pointer_t<decay_t<From>>,
                             std::remove_pointer_t<decay_t<To>>>));

        template<std::size_t N, typename T>
        using tuple_element_fun_t = void (*)(meta::_t<std::tuple_element<N, T>> const &);

        
        
        template<typename T>
        concept pair_like_impl_requires_ = requires(T t, tuple_element_fun_t<0, T> p0, tuple_element_fun_t<1, T> p1) { p0( get<0>(t) ), p1( get<1>(t) ); };
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        
        
        template<typename T>
        concept pair_like_impl_ = detail::pair_like_impl_requires_<T>;

        
        
         template<typename T > concept is_complete_concept_ = 0 != sizeof(T);
#line 85 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

        
        
        template<typename T>
        concept is_complete_ = 
            is_complete_concept_<T>;

         template<typename T > concept pair_like_concept_ = is_complete_<std::tuple_size<T>> && derived_from<std::tuple_size<T>, meta::size_t<2>> && detail::pair_like_impl_<T>;
#line 97 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

        
        
        template<typename T>
        concept pair_like = 
            detail::pair_like_concept_<T>;

        
         template<typename T, typename U, typename V > concept pair_like_convertible_from_helper_concept_ = convertible_to_not_slicing_<U, meta::_t<std::tuple_element<0, T>>> && convertible_to<V, meta::_t<std::tuple_element<1, T>>>;
#line 109 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

        
        
        template<typename T, typename U, typename V>
        concept pair_like_convertible_from_helper_ = 
            pair_like_convertible_from_helper_concept_<T, U, V>;

         template<typename T, typename U, typename V > concept pair_like_convertible_from_impl_concept_ = (!range<T>) && constructible_from<T, U, V> && pair_like<uncvref_t<T>> && pair_like_convertible_from_helper_<T, U, V>;
#line 122 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

        
        
        template<typename T, typename U, typename V>
        concept pair_like_convertible_from_ =
            detail::pair_like_convertible_from_impl_concept_<T, U, V>;

        
        
         template<typename R, typename I, typename S > concept range_convertible_to_impl_concept_ = convertible_to_not_slicing_<iterator_t<R>, I> && convertible_to<sentinel_t<R>, S>;
#line 135 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

        
        
        template<typename R, typename I, typename S>
        concept range_convertible_to_ =
            borrowed_range<R> &&
            detail::range_convertible_to_impl_concept_<R, I, S>;
        

         template<typename S, typename I > requires sentinel_for<S, I>
#line 146 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr bool is_sized_sentinel_() noexcept
        {
            return (bool)sized_sentinel_for<S, I>;
        }

        template<subrange_kind K, typename S, typename I>
        constexpr bool store_size_() noexcept
        {
            return K == subrange_kind::sized && !(bool)sized_sentinel_for<S, I>;
        }
    } 
    

    template< 
        typename I, 
        typename S = I, 
        subrange_kind K = static_cast<subrange_kind>(detail::is_sized_sentinel_<S, I>())>
    struct subrange;

    template<typename I, typename S, subrange_kind K>
    inline constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;

    
    namespace _subrange_
    {
        struct adl_hook
        {};

         template<std::size_t N, typename I, typename S, subrange_kind K > requires (N == 0) 
#line 176 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr I get(subrange<I, S, K> const & r)
        {
            return r.begin();
        }
         template<std::size_t N, typename I, typename S, subrange_kind K > requires (N == 1) 
#line 182 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr S get(subrange<I, S, K> const & r)
        {
            return r.end();
        }
    } 
    

    template<typename I, typename S, subrange_kind K>
    struct subrange
      : view_interface<subrange<I, S, K>,
                       same_as<S, unreachable_sentinel_t>
                           ? infinite
                           : K == subrange_kind::sized ? finite : unknown>
      , private _subrange_::adl_hook
    {
        static_assert(static_cast<bool>(input_or_output_iterator<I>), "Concept assertion failed : " "input_or_output_iterator<I>");
        static_assert(static_cast<bool>(sentinel_for<S, I>), "Concept assertion failed : " "sentinel_for<S, I>");
        static_assert(static_cast<bool>(K == subrange_kind::sized || !sized_sentinel_for<S, I>), "Concept assertion failed : " "K == subrange_kind::sized || !sized_sentinel_for<S, I>");
        static_assert(static_cast<bool>(K != subrange_kind::sized || !same_as<S, unreachable_sentinel_t>), "Concept assertion failed : " "K != subrange_kind::sized || !same_as<S, unreachable_sentinel_t>");

        using size_type = detail::iter_size_t<I>;
        using iterator = I;
        using sentinel = S;

        subrange() = default;

         template<typename I2 > requires detail::convertible_to_not_slicing_<I2, I> && (!detail::store_size_<K, S, I>()) 
#line 211 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange(I2 && i, S s)
          : data_{static_cast<I2 &&>(i), std::move(s)}
        {}

         template<typename I2 > requires detail::convertible_to_not_slicing_<I2, I> && (detail::store_size_<K, S, I>()) 
#line 218 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange(I2 && i, S s, size_type n)
          : data_{static_cast<I2 &&>(i), std::move(s), n}
        {
            if(false) {} else if constexpr((bool)random_access_iterator<I>)
            {
                using D = iter_difference_t<I>;
                static_cast<void>((n <= (size_type)std::numeric_limits<D>::max()) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp", 224, "assertion failed: " "n <= (size_type)std::numeric_limits<D>::max()"));
                static_cast<void>((ranges::next(first_(), (D)n) == last_()) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp", 225, "assertion failed: " "ranges::next(first_(), (D)n) == last_()"));
            }
        }
         template<typename I2 > requires detail::convertible_to_not_slicing_<I2, I> && sized_sentinel_for<S, I>
#line 231 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange(I2 && i, S s, size_type n)
          : data_{static_cast<I2 &&>(i), std::move(s)}
        {
            static_cast<void>((static_cast<size_type>(last_() - first_()) == n) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp", 234, "assertion failed: " "static_cast<size_type>(last_() - first_()) == n"));
        }

         template<typename R > requires (!same_as<detail::decay_t<R>, subrange>) && detail::range_convertible_to_<R, I, S> && (!detail::store_size_<K, S, I>())
#line 241 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange(R && r)
          : subrange{ranges::begin(r), ranges::end(r)}
        {}

         template<typename R > requires (!same_as<detail::decay_t<R>, subrange>) && detail::range_convertible_to_<R, I, S> && (detail::store_size_<K, S, I>()) && sized_range<R>
#line 250 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange(R && r)
          : subrange{ranges::begin(r), ranges::end(r), ranges::size(r)}
        {}

         template<typename R > requires (K == subrange_kind::sized) && detail::range_convertible_to_<R, I, S>
#line 257 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange(R && r, size_type n) 
          : subrange{ranges::begin(r), ranges::end(r), n}
        {
            if(false) {} else if constexpr((bool)sized_range<R>)
            {
                static_cast<void>((n == ranges::size(r)) ? void(0) : ::ranges::detail::assert_failure( "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp", 262, "assertion failed: " "n == ranges::size(r)"));
            }
        }

         template<typename PairLike > requires (!same_as<PairLike, subrange>) && detail::pair_like_convertible_from_<PairLike, I const &, S const &>
#line 269 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr operator PairLike() const
        {
            return PairLike(first_(), last_());
        }

        constexpr I begin() const noexcept(std::is_nothrow_copy_constructible<I>::value)
        {
            return first_();
        }
        constexpr S end() const noexcept(std::is_nothrow_copy_constructible<S>::value)
        {
            return last_();
        }
        constexpr bool empty() const
        {
            return first_() == last_();
        }

        
        constexpr auto size() const 
            -> size_type requires (K == subrange_kind::sized)
#line 291 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        {
            return get_size_();
        }

        [[nodiscard]]
        constexpr subrange next(iter_difference_t<I> n = 1) const
        {
            auto tmp = *this;
            tmp.advance(n);
            return tmp;
        }

        
        [[nodiscard]] constexpr auto prev(iter_difference_t<I> n = 1) const
            -> subrange requires bidirectional_iterator<I>
#line 307 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        {
            auto tmp = *this;
            tmp.advance(-n);
            return tmp;
        }

        constexpr subrange & advance(iter_difference_t<I> n)
        {
            set_size_(get_size_() -
                      static_cast<size_type>(n - ranges::advance(first_(), n, last_())));
            return *this;
        }

    private:
        using data_t =
            meta::conditional_t< 
                detail::store_size_<K, S, I>(), 
                std::tuple<I, S, size_type>, 
                std::tuple<I, S>>;
        data_t data_;

        constexpr I & first_() noexcept
        {
            return std::get<0>(data_);
        }
        constexpr const I & first_() const noexcept
        {
            return std::get<0>(data_);
        }
        constexpr S & last_() noexcept
        {
            return std::get<1>(data_);
        }
        constexpr const S & last_() const noexcept
        {
            return std::get<1>(data_);
        }
        
        constexpr auto get_size_() const 
            -> size_type requires sized_sentinel_for<S, I>
#line 348 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        {
            return static_cast<size_type>(last_() - first_());
        }
        
        constexpr auto get_size_() const noexcept 
            -> size_type requires (detail::store_size_<K, S, I>())
#line 355 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        {
            return std::get<2>(data_);
        }
        static constexpr void set_size_(...) noexcept
        {}
        
        constexpr auto set_size_(size_type n) noexcept 
            -> void requires (detail::store_size_<K, S, I>())
#line 364 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        {
            std::get<2>(data_) = n;
        }
    };


    template<typename I, typename S>
    subrange(I, S) 
        -> subrange<I, S>;

     template<typename I, typename S > requires input_or_output_iterator<I> && sentinel_for<S, I>
#line 376 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
    subrange(I, S, detail::iter_size_t<I>)
        -> subrange<I, S, subrange_kind::sized>;

     template<typename R > requires borrowed_range<R>
#line 381 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
    subrange(R &&) 
        -> subrange<iterator_t<R>, sentinel_t<R>,
                    (sized_range<R> ||
                        sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                           ? subrange_kind::sized
                           : subrange_kind::unsized>;

     template<typename R > requires borrowed_range<R>
#line 390 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
    subrange(R &&, detail::iter_size_t<iterator_t<R>>)
        -> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;
#line 393 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

    
    struct make_subrange_fn
    {
        template<typename I, typename S>
        constexpr subrange<I, S> operator()(I i, S s) const
        {
            return {i, s};
        }
         template<typename I, typename S > requires input_or_output_iterator<I> && sentinel_for<S, I>
#line 404 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange<I, S, subrange_kind::sized> 
        operator()(I i, S s, detail::iter_size_t<I> n) const
        {
            return {i, s, n};
        }
         template<typename R > requires borrowed_range<R>
#line 411 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr auto operator()(R && r) const
            -> subrange<iterator_t<R>, sentinel_t<R>,
                     (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                         ? subrange_kind::sized
                         : subrange_kind::unsized>
        {
            return {(R &&) r};
        }
         template<typename R > requires borrowed_range<R>
#line 421 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        constexpr subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized> 
        operator()(R && r, detail::iter_size_t<iterator_t<R>> n) const
        {
            return {(R &&) r, n};
        }
    };

    
    
    inline constexpr make_subrange_fn make_subrange{};

    template<typename R>
    using borrowed_subrange_t = detail::maybe_dangling_<R, subrange<iterator_t<R>>>;

    template<typename R>
    using safe_subrange_t [[deprecated("Use borrowed_subrange_t instead.")]] =
        borrowed_subrange_t<R>;

    namespace cpp20
    {
        using ranges::subrange_kind;

         template<typename I, typename S = I, subrange_kind K = static_cast<subrange_kind>( detail::is_sized_sentinel_<S, I>()) > requires input_or_output_iterator<I> && sentinel_for<S, I> && (K == subrange_kind::sized || !sized_sentinel_for<S, I>)   
#line 450 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
        using subrange = ranges::subrange<I, S, K>;

        using ranges::borrowed_subrange_t;

        template<typename R>
        using safe_subrange_t [[deprecated("Use borrowed_subrange_t instead.")]] =
            borrowed_subrange_t<R>;
    } 
    
} 

__pragma(warning(push))
__pragma(warning(disable : 4068)) __pragma(warning(disable : 4099))

namespace std
{
    template<typename I, typename S, ::ranges::subrange_kind K>
    struct tuple_size<::ranges::subrange<I, S, K>> : std::integral_constant<size_t, 2>
    {};
    template<typename I, typename S, ::ranges::subrange_kind K>
    struct tuple_element<0, ::ranges::subrange<I, S, K>>
    {
        using type = I;
    };
    template<typename I, typename S, ::ranges::subrange_kind K>
    struct tuple_element<1, ::ranges::subrange<I, S, K>>
    {
        using type = S;
    };
} 

__pragma(warning(pop))

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 484 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"

#line 486 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/subrange.hpp"
#pragma external_header(pop)
#line 28 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"































#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 33 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"

namespace ranges
{
    
    

    
    namespace detail
    {
        struct dereference_fn
        {
            
            template<typename I>
            constexpr auto operator() (I &&i) const noexcept(noexcept(*(I &&) i)) -> decltype(*(I &&) i) { return (*(I &&) i); }
#line 50 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            
        };

        struct view_closure_base_
        {};
    } 
      

    
    
    
     template<typename Rng > concept simple_view_impl_concept_ = same_as<iterator_t<Rng>, iterator_t<Rng const>> && same_as<sentinel_t<Rng>, sentinel_t<Rng const>>;
#line 65 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"

    
    
    template<typename Rng>
    concept simple_view_ =
        view_<Rng> &&
        range<Rng const> &&
        ranges::simple_view_impl_concept_<Rng>;

    
    
     template<typename ViewFn, typename Rng > concept invocable_view_closure_concept_ = !derived_from<invoke_result_t<ViewFn, Rng>, detail::view_closure_base_>;
#line 79 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"

    
    
    template<typename ViewFn, typename Rng>
    concept invocable_view_closure =
        invocable<ViewFn, Rng> &&
        ranges::invocable_view_closure_concept_<ViewFn, Rng>;
    

    template<typename Rng>
    constexpr bool simple_view() noexcept
    {
        return (bool)simple_view_<Rng>;
    }

    struct make_view_closure_fn
    {
        template<typename Fun>
        constexpr views::view_closure<Fun> operator()(Fun fun) const
        {
            return views::view_closure<Fun>{static_cast<Fun &&>(fun)};
        }
    };

    
    
    inline constexpr make_view_closure_fn make_view_closure{};

    namespace views
    {
        struct _ranges_adl_barrier_noop_; namespace view_closure_base_ns { struct view_closure_base; } using view_closure_base_ns::view_closure_base; struct view_closure_base_ns::view_closure_base
          : detail::view_closure_base_
        {
            
            
             template<typename Rng, typename ViewFn > requires viewable_range<Rng> && invocable_view_closure<ViewFn, Rng>
#line 117 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            friend constexpr auto operator|(Rng && rng, view_closure<ViewFn> vw)
            {
                return static_cast<ViewFn &&>(vw)(static_cast<Rng &&>(rng));
            }


            
            
            template<typename Rng, typename ViewFn>         
            friend constexpr auto                           
            operator|(Rng &&, view_closure<ViewFn> const &) 
                                                            
                -> ::concepts::return_t< Rng, std::enable_if_t<( range<Rng> && (!viewable_range<Rng>) && CPP_true_fn(::concepts::detail::xNil{}))>> = delete;       
#line 132 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            
            
            
            
            
            
            
#line 140 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"

            template<typename ViewFn, typename Pipeable>
            friend constexpr auto operator|(view_closure<ViewFn> vw, Pipeable pipe)
                -> ::concepts::return_t< view_closure<composed<Pipeable, ViewFn>>, std::enable_if_t<( (is_pipeable_v<Pipeable>) && CPP_true_fn(::concepts::detail::xNil{}))>>
#line 145 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            {
                return make_view_closure(
                    compose(static_cast<Pipeable &&>(pipe), static_cast<ViewFn &&>(vw)));
            }
        };
























        template<typename ViewFn>
        struct __declspec(empty_bases) view_closure
          : view_closure_base
          , ViewFn
        {
            view_closure() = default;

            constexpr explicit view_closure(ViewFn fn)
              : ViewFn(static_cast<ViewFn &&>(fn))
            {}
        };

        
        
        struct view_access_
        {
            template<typename ViewFn>
            struct impl
            {
                
                template<typename... Ts, typename V = ViewFn>
                static constexpr auto bind (Ts &&... ts) noexcept(noexcept(V::bind(static_cast<Ts &&>(ts)...))) -> decltype(V::bind(static_cast<Ts &&>(ts)...)) { return (V::bind(static_cast<Ts &&>(ts)...)); }
#line 199 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
                
            };
        };

        using view_access [[deprecated("view_access and views::view<> are deprecated. Please " "replace view<> with view_closure<> and discontinue use of view_access.")]] =
#line 206 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            view_access_;

        template<typename>
        struct old_view_;

        struct make_view_fn_
        {
            template<typename Fun>
            constexpr old_view_<Fun> operator()(Fun fun) const
            {
                return old_view_<Fun>{static_cast<Fun &&>(fun)};
            }
        };
        using make_view_fn [[deprecated("make_view_fn is deprecated. Please use " "make_view_closure instead.")]] = make_view_fn_;
#line 222 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"

        namespace
        {
            [[deprecated("make_view and views::view<> has been deprecated. Please switch to " "make_view_closure and views::view_closure.")]]
#line 228 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            inline constexpr auto & make_view =
                static_const<make_view_fn_>::value;
        } 

        template<typename ViewFn>
        struct old_view_ : pipeable_base
        {
        private:
            ViewFn vw_;
            friend pipeable_access;

            
             template<typename Rng, typename Vw > requires viewable_range<Rng> && invocable<ViewFn &, Rng>
#line 242 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            static constexpr auto pipe(Rng && rng, Vw && v)
            {
                return v.vw_(static_cast<Rng &&>(rng));
            }

        public:
            old_view_() = default;

            constexpr explicit old_view_(ViewFn a) noexcept(
                std::is_nothrow_move_constructible<ViewFn>::value)
              : vw_(std::move(a))
            {}

            
             template<typename Rng, typename... Rest > requires viewable_range<Rng> && invocable<ViewFn const &, Rng, Rest...>
#line 258 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            constexpr invoke_result_t<ViewFn const &, Rng, Rest...> 
            operator()(Rng && rng, Rest &&... rest) const
            {
                return vw_(static_cast<Rng &&>(rng), static_cast<Rest &&>(rest)...);
            }

            
            
            template<typename... Ts, typename V = ViewFn>
            constexpr auto operator() (Ts &&... ts) const noexcept(noexcept(make_view_fn_{}( view_access_::impl<V>::bind(vw_, static_cast<Ts &&>(ts)...)))) -> decltype(make_view_fn_{}( view_access_::impl<V>::bind(vw_, static_cast<Ts &&>(ts)...))) { return (make_view_fn_{}( view_access_::impl<V>::bind(vw_, static_cast<Ts &&>(ts)...))); }
#line 272 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            
        };

        template<typename ViewFn>
        using view [[deprecated("The views::view<> template is deprecated. Please switch to view_closure")]] =
#line 278 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
            old_view_<ViewFn>;
        
    } 

    template<typename ViewFn>
    inline constexpr bool is_pipeable_v<views::view_closure<ViewFn>> = true;
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 288 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"

#line 290 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/view.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"

namespace ranges
{
    
    
    namespace views
    {
        struct all_fn
        {
        private:
            
            template<typename T>
            static constexpr auto from_range_(T && t, std::true_type, detail::ignore_t,
                                              detail::ignore_t)
            {
                return static_cast<T &&>(t);
            }

            
            
            template<typename T>
            static constexpr auto from_range_(T && t, std::false_type, std::true_type,
                                              detail::ignore_t)
            {
                return ranges::views::ref(t);
            }

            
            
            template<typename T>
            static constexpr auto from_range_(T && t, std::false_type, std::false_type,
                                              std::true_type)
            {
                return make_subrange(static_cast<T &&>(t));
            }

        public:
             template<typename T > requires range<T &> && viewable_range<T>
#line 70 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"
            constexpr auto operator()(T && t) const
            {
                return all_fn::from_range_(static_cast<T &&>(t),
                                           meta::bool_<view_<uncvref_t<T>>>{},
                                           std::is_lvalue_reference<T>{},
                                           meta::bool_<borrowed_range<T>>{});
            }

            template<typename T>
            [[deprecated("Passing a reference_wrapper to views::all is deprecated.")]]
            constexpr ref_view<T> operator()(std::reference_wrapper<T> r) const
            {
                return ranges::views::ref(r.get());
            }
        };

        
        
        inline constexpr view_closure<all_fn> all{};

        template<typename Rng>
        using all_t = decltype(all(std::declval<Rng>()));
    } 

    template<typename Rng>
    struct identity_adaptor : Rng
    {
        static_assert(static_cast<bool>(view_<Rng>), "Concept assertion failed : " "view_<Rng>");

        identity_adaptor() = default;
        constexpr explicit identity_adaptor(Rng const & rng)
          : Rng(rng)
        {}
        constexpr explicit identity_adaptor(Rng && rng)
          : Rng(detail::move(rng))
        {}
    };

    namespace cpp20
    {
        namespace views
        {
            using ranges::views::all;
            using ranges::views::all_t;
        }
         template<typename Rng > requires viewable_range<Rng>
#line 117 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"
        using all_view [[deprecated("Please use ranges::cpp20::views::all_t instead.")]] =
#line 119 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"
                ranges::views::all_t<Rng>;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"

#line 127 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/all.hpp"
#pragma external_header(pop)
#line 29 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"

























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/default_sentinel.hpp"


















#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 20 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/default_sentinel.hpp"

namespace ranges
{
    
    
    struct default_sentinel_t
    {};

    
    inline constexpr default_sentinel_t default_sentinel{};

    namespace cpp20
    {
        using ranges::default_sentinel;
        using ranges::default_sentinel_t;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 40 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/default_sentinel.hpp"

#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/iterator/default_sentinel.hpp"
#pragma external_header(pop)
#line 27 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 31 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename Derived>
        using begin_cursor_t = detail::decay_t<decltype(
            range_access::begin_cursor(std::declval<Derived &>()))>;

        template<typename Derived>
        using end_cursor_t = detail::decay_t<decltype(
            range_access::end_cursor(std::declval<Derived &>()))>;

        template<typename Derived>
        using facade_iterator_t = basic_iterator<begin_cursor_t<Derived>>;

        template<typename Derived>
        using facade_sentinel_t =
            meta::if_c<same_as<begin_cursor_t<Derived>, end_cursor_t<Derived>>,
                       facade_iterator_t<Derived>, end_cursor_t<Derived>>;
    } 
    

    
    

    
    
    
    
    
    
    template<typename Derived, cardinality Cardinality>
    struct view_facade : view_interface<Derived, Cardinality>
    {
    protected:
        friend range_access;
        struct view_as_cursor : Derived
        {
            view_as_cursor() = default;
            explicit view_as_cursor(Derived const * derived)
              : Derived(*derived)
            {}
            explicit operator bool() = delete;
            explicit operator bool() const = delete;
        };
        
        constexpr view_as_cursor begin_cursor() const
        {
            return view_as_cursor{static_cast<Derived const *>(this)};
        }
        constexpr default_sentinel_t end_cursor() const
        {
            return {};
        }

    public:
        
        
        
        
        
         template<typename D = Derived > requires same_as<D, Derived>
#line 96 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"
        constexpr auto begin() -> detail::facade_iterator_t<D>
        {
            return detail::facade_iterator_t<D>{
                range_access::begin_cursor(*static_cast<Derived *>(this))};
        }
        
         template<typename D = Derived > requires same_as<D, Derived>
#line 104 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"
        constexpr auto begin() const -> detail::facade_iterator_t<D const>
        {
            return detail::facade_iterator_t<D const>{
                range_access::begin_cursor(*static_cast<Derived const *>(this))};
        }
        
        
        
        
        
        
         template<typename D = Derived > requires same_as<D, Derived>
#line 117 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"
        constexpr auto end() -> detail::facade_sentinel_t<D>
        {
            return static_cast<detail::facade_sentinel_t<D>>(
                range_access::end_cursor(*static_cast<Derived *>(this)));
        }
        
         template<typename D = Derived > requires same_as<D, Derived>
#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"
        constexpr auto end() const -> detail::facade_sentinel_t<D const>
        {
            return static_cast<detail::facade_sentinel_t<D const>>(
                range_access::end_cursor(*static_cast<Derived const *>(this)));
        }
    };

    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 136 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"

#line 138 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/facade.hpp"
#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 32 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"

namespace ranges
{
    
    namespace detail
    {
        template<typename Derived>
        using begin_adaptor_t = detail::decay_t<decltype(
            range_access::begin_adaptor(std::declval<Derived &>()))>;

        template<typename Derived>
        using end_adaptor_t = detail::decay_t<decltype(
            range_access::end_adaptor(std::declval<Derived &>()))>;

        template<typename Derived>
        using adapted_iterator_t = detail::decay_t<decltype(
            std::declval<begin_adaptor_t<Derived>>().begin(std::declval<Derived &>()))>;

        template<typename Derived>
        using adapted_sentinel_t = detail::decay_t<decltype(
            std::declval<end_adaptor_t<Derived>>().end(std::declval<Derived &>()))>;

        struct adaptor_base_current_mem_fn
        {};

        template<typename BaseIter, typename Adapt>
        constexpr int which_adaptor_value_(priority_tag<0>)
        {
            return 0;
        }
        template<typename BaseIter, typename Adapt>
        constexpr always_<int, decltype(Adapt::read(std::declval<BaseIter const &>(),
                                                    adaptor_base_current_mem_fn{}))> 
        which_adaptor_value_(priority_tag<1>)
        {
            return 1;
        }
        template<typename BaseIter, typename Adapt>
        constexpr always_<int, typename Adapt::value_type> 
        which_adaptor_value_(priority_tag<2>)
        {
            return 2;
        }

        template<typename BaseIter, typename Adapt,
                 int = detail::which_adaptor_value_<BaseIter, Adapt>(priority_tag<2>{})>
        struct adaptor_value_type_
        {
            compressed_pair<BaseIter, Adapt> data_;
        };
        template<typename BaseIter, typename Adapt>
        struct adaptor_value_type_<BaseIter, Adapt, 1>
        {
            using value_type = iter_value_t<BaseIter>;
            compressed_pair<BaseIter, Adapt> data_;
        };
        template<typename BaseIter, typename Adapt>
        struct adaptor_value_type_<BaseIter, Adapt, 2>
        {

            using value_type = typename indirectly_readable_traits<Adapt>::value_type;


#line 96 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
            compressed_pair<BaseIter, Adapt> data_;
        };
    } 
    

    
    
    template<typename BaseIt, typename Adapt>
    struct adaptor_cursor;

    template<typename BaseSent, typename Adapt>
    struct base_adaptor_sentinel;

    struct adaptor_base
    {
        adaptor_base() = default;
        adaptor_base(adaptor_base &&) = default;
        adaptor_base(adaptor_base const &) = default;
        adaptor_base & operator=(adaptor_base &&) = default;
        adaptor_base & operator=(adaptor_base const &) = default;

        adaptor_base(detail::ignore_t, detail::ignore_t = {}, detail::ignore_t = {})
        {}
        
        template<typename Rng>
        static constexpr auto begin (Rng &rng) noexcept(noexcept(ranges::begin(rng.base()))) -> decltype(ranges::begin(rng.base())) { return (ranges::begin(rng.base())); }
#line 125 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        template<typename Rng>
        static constexpr auto end (Rng &rng) noexcept(noexcept(ranges::end(rng.base()))) -> decltype(ranges::end(rng.base())) { return (ranges::end(rng.base())); }
#line 130 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
            
             template<typename I > requires equality_comparable<I>
#line 133 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
            static bool equal(I const & it0, I const & it1)
        {
            return it0 == it1;
        }
         template<typename I > requires input_or_output_iterator<I>
#line 139 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        static iter_reference_t<I> read(I const & it,
                                        detail::adaptor_base_current_mem_fn = {})
            noexcept(noexcept(iter_reference_t<I>(*it)))
        {
            return *it;
        }
         template<typename I > requires input_or_output_iterator<I>
#line 147 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        static void next(I & it)
        {
            ++it;
        }
         template<typename I > requires bidirectional_iterator<I>
#line 153 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        static void prev(I & it)
        {
            --it;
        }
         template<typename I > requires random_access_iterator<I>
#line 159 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        static void advance(I & it, iter_difference_t<I> n)
        {
            it += n;
        }
         template<typename I > requires sized_sentinel_for<I, I>
#line 165 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        static iter_difference_t<I> distance_to(I const & it0, I const & it1)
        {
            return it1 - it0;
        }
         template<typename I, typename S > requires sentinel_for<S, I>
#line 171 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        static constexpr bool empty(I const & it, S const & last)
        {
            return it == last;
        }
    };

    
    
    template<typename BaseSent, typename Adapt>
    struct base_adaptor_sentinel
    {
    private:
        template<typename, typename>
        friend struct adaptor_cursor;
         compressed_pair<BaseSent, Adapt> data_;

    public:
        base_adaptor_sentinel() = default;
        base_adaptor_sentinel(BaseSent sent, Adapt adapt)
          : data_{std::move(sent), std::move(adapt)}
        {}

        
        
        BaseSent base() const
        {
            return data_.first();
        }

    protected:
        
        Adapt & get()
        {
            return data_.second();
        }
        Adapt const & get() const
        {
            return data_.second();
        }
    };

    
    namespace detail
    {
        template<typename BaseSent, typename Adapt>
        meta::id<base_adaptor_sentinel<BaseSent, Adapt>> base_adaptor_sentinel_2_(long);

        template<typename BaseSent, typename Adapt>
        meta::id<typename Adapt::template mixin<base_adaptor_sentinel<BaseSent, Adapt>>>
        base_adaptor_sentinel_2_(int);

        template<typename BaseSent, typename Adapt>
        struct base_adaptor_sentinel_
          : decltype(base_adaptor_sentinel_2_<BaseSent, Adapt>(42))
        {};

        template<typename BaseSent, typename Adapt>
        using adaptor_sentinel_ = meta::_t<base_adaptor_sentinel_<BaseSent, Adapt>>;
    } 
    

    template<typename BaseSent, typename Adapt>
    struct adaptor_sentinel : detail::adaptor_sentinel_<BaseSent, Adapt>
    {
        using detail::adaptor_sentinel_<BaseSent, Adapt>::adaptor_sentinel_;
    };

    
    
    template<typename BaseIter, typename Adapt>
    struct adaptor_cursor : private detail::adaptor_value_type_<BaseIter, Adapt>
    {
    private:
        friend range_access;
        template<typename, typename>
        friend struct adaptor_cursor;
        using base_t = detail::adaptor_value_type_<BaseIter, Adapt>;
        using single_pass = meta::bool_<(bool)range_access::single_pass_t<Adapt>() ||
                                        (bool)single_pass_iterator_<BaseIter>>;

        struct basic_adaptor_mixin : basic_mixin<adaptor_cursor>
        {
            basic_adaptor_mixin() = default;
            


            constexpr explicit basic_adaptor_mixin(adaptor_cursor && cur)
              : basic_mixin<adaptor_cursor>(static_cast<adaptor_cursor &&>(cur))
            {}
            constexpr explicit basic_adaptor_mixin(adaptor_cursor const & cur)
              : basic_mixin<adaptor_cursor>(cur)
            {}
            #line 264 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
            
            
            BaseIter base() const
            {
                return basic_adaptor_mixin::basic_mixin::get().data_.first();
            }

        protected:
            
            Adapt & get()
            {
                return basic_adaptor_mixin::basic_mixin::get().data_.second();
            }
            const Adapt & get() const
            {
                return basic_adaptor_mixin::basic_mixin::get().data_.second();
            }
        };

        template<typename Adapt_>
        static meta::id<basic_adaptor_mixin> basic_adaptor_mixin_2_(long);

        template<typename Adapt_>
        static meta::id<typename Adapt_::template mixin<basic_adaptor_mixin>>
        basic_adaptor_mixin_2_(int);

        using mixin = meta::_t<decltype(basic_adaptor_mixin_2_<Adapt>(42))>;

        template<typename A = Adapt, typename R = decltype(std::declval<A const &>().read(
                                         std::declval<BaseIter const &>()))>
        R read() const noexcept(
            noexcept(std::declval<A const &>().read(std::declval<BaseIter const &>())))
        {
            using V = range_access::cursor_value_t<adaptor_cursor>;
            static_assert(common_reference_with<R &&, V &>,
                          "In your adaptor, you've specified a value type that does not "
                          "share a common reference type with the return type of read.");
            return this->data_.second().read(this->data_.first());
        }
        template<typename A = Adapt, typename = decltype(std::declval<A &>().next(
                                         std::declval<BaseIter &>()))>
        void next()
        {
            this->data_.second().next(this->data_.first());
        }
        template<typename A = Adapt,
                 typename = decltype(std::declval<A const &>().equal(
                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>(),
                     std::declval<A const &>()))>
        bool equal_(adaptor_cursor const & that, int) const
        {
            return this->data_.second().equal(
                this->data_.first(), that.data_.first(), that.data_.second());
        }
        template<typename A = Adapt,
                 typename = decltype(std::declval<A const &>().equal(
                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>()))>
        bool equal_(adaptor_cursor const & that, long) const
        {
            return this->data_.second().equal(this->data_.first(), that.data_.first());
        }
        template<typename C = adaptor_cursor>
        auto equal(adaptor_cursor const & that) const
            -> decltype(std::declval<C const &>().equal_(that, 42))
        {
            return this->equal_(that, 42);
        }
        template<typename S, typename A,
                 typename = decltype(std::declval<A const &>().empty(
                     std::declval<BaseIter const &>(), std::declval<Adapt const &>(),
                     std::declval<S const &>()))>
        constexpr bool equal_(adaptor_sentinel<S, A> const & that, int) const
        {
            return that.data_.second().empty(
                this->data_.first(), this->data_.second(), that.data_.first());
        }
        template<typename S, typename A,
                 typename = decltype(std::declval<A const &>().empty(
                     std::declval<BaseIter const &>(), std::declval<S const &>()))>
        constexpr bool equal_(adaptor_sentinel<S, A> const & that, long) const
        {
            return that.data_.second().empty(this->data_.first(), that.data_.first());
        }
        template<typename S, typename A>
        constexpr auto equal(adaptor_sentinel<S, A> const & that) const
            -> decltype(std::declval<adaptor_cursor const &>().equal_(that, 42))
        {
            return this->equal_(that, 42);
        }
        template<typename A = Adapt, typename = decltype(std::declval<A &>().prev(
                                         std::declval<BaseIter &>()))>
        void prev()
        {
            this->data_.second().prev(this->data_.first());
        }
        template<typename A = Adapt, typename = decltype(std::declval<A &>().advance(
                                         std::declval<BaseIter &>(), 0))>
        void advance(iter_difference_t<BaseIter> n)
        {
            this->data_.second().advance(this->data_.first(), n);
        }
        template<typename A = Adapt,
                 typename R = decltype(std::declval<A const &>().distance_to(
                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>(),
                     std::declval<A const &>()))>
        R distance_to_(adaptor_cursor const & that, int) const
        {
            return this->data_.second().distance_to(
                this->data_.first(), that.data_.first(), that.data_.second());
        }
        template<typename A = Adapt,
                 typename R = decltype(std::declval<A const &>().distance_to(
                     std::declval<BaseIter const &>(), std::declval<BaseIter const &>()))>
        R distance_to_(adaptor_cursor const & that, long) const
        {
            return this->data_.second().distance_to(this->data_.first(),
                                                    that.data_.first());
        }
        template<typename C = adaptor_cursor>
        auto distance_to(adaptor_cursor const & that) const
            -> decltype(std::declval<C const &>().distance_to_(that, 42))
        {
            return this->distance_to_(that, 42);
        }
        
        template<typename A = Adapt,
                 typename X = decltype(std::declval<A const &>().iter_move(
                     std::declval<BaseIter const &>()))>
        X iter_move_(int) const noexcept(noexcept(
            std::declval<A const &>().iter_move(std::declval<BaseIter const &>())))
        {
            using V = range_access::cursor_value_t<adaptor_cursor>;
            using R = decltype(this->data_.second().read(this->data_.first()));
            static_assert(
                common_reference_with<X &&, V const &>,
                "In your adaptor, the result of your iter_move member function does "
                "not share a common reference with your value type.");
            static_assert(
                common_reference_with<R &&, X &&>,
                "In your adaptor, the result of your iter_move member function does "
                "not share a common reference with the result of your read member "
                "function.");
            return this->data_.second().iter_move(this->data_.first());
        }
        
        
        template<typename A = Adapt,
                 typename R = decltype(std::declval<A const &>().read(
                     std::declval<BaseIter const &>(),
                     detail::adaptor_base_current_mem_fn{})),
                 typename X = iter_rvalue_reference_t<BaseIter>>
        X iter_move_(long) const
            noexcept(noexcept(X(ranges::iter_move(std::declval<BaseIter const &>()))))
        {
            return ranges::iter_move(this->data_.first());
        }
        
        
        template<typename A = Adapt,
                 typename R = decltype(
                     std::declval<A const &>().read(std::declval<BaseIter const &>())),
                 typename X = aux::move_t<R>>
        X iter_move_(detail::ignore_t) const noexcept(noexcept(X(static_cast<X &&>(
            std::declval<A const &>().read(std::declval<BaseIter const &>())))))
        {
            using V = range_access::cursor_value_t<adaptor_cursor>;
            static_assert(
                common_reference_with<X &&, V const &>,
                "In your adaptor, you've specified a value type that does not share a "
                "common "
                "reference type with the result of moving the result of the read member "
                "function. Consider defining an iter_move function in your adaptor.");
            return static_cast<X &&>(this->data_.second().read(this->data_.first()));
        }
        
        auto move() const
            noexcept(noexcept(std::declval<const adaptor_cursor &>().iter_move_(42)))
                -> decltype(std::declval<const adaptor_cursor &>().iter_move_(42))
        {
            return iter_move_(42);
        }

    public:
        adaptor_cursor() = default;
        adaptor_cursor(BaseIter iter, Adapt adapt)
          : base_t{{std::move(iter), std::move(adapt)}}
        {}
         template<typename OtherIter, typename OtherAdapt > requires (!same_as<adaptor_cursor<OtherIter, OtherAdapt>, adaptor_cursor>) && convertible_to<OtherIter, BaseIter> && convertible_to<OtherAdapt, Adapt>
#line 456 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        adaptor_cursor(adaptor_cursor<OtherIter, OtherAdapt> that)
          : base_t{{std::move(that.data_.first()), std::move(that.data_.second())}}
        {}
    };

    template<typename D>
    using adaptor_cursor_t =
        adaptor_cursor<detail::adapted_iterator_t<D>, detail::begin_adaptor_t<D>>;

    template<typename D>
    using adaptor_sentinel_t = meta::if_c<
        same_as<detail::adapted_iterator_t<D>, detail::adapted_sentinel_t<D>> &&
            same_as<detail::begin_adaptor_t<D>, detail::end_adaptor_t<D>>,
        adaptor_cursor_t<D>,
        adaptor_sentinel<detail::adapted_sentinel_t<D>, detail::end_adaptor_t<D>>>;

    template<typename Derived, typename BaseRng,
             cardinality Cardinality >
    struct view_adaptor : view_facade<Derived, Cardinality>
    {
    private:
        friend Derived;
        friend range_access;
        friend adaptor_base;
        static_assert(static_cast<bool>(viewable_range<BaseRng>), "Concept assertion failed : " "viewable_range<BaseRng>");
        using base_range_t = views::all_t<BaseRng>;
        using view_facade<Derived, Cardinality>::derived;

        base_range_t rng_;

        constexpr adaptor_base begin_adaptor() const noexcept
        {
            return {};
        }
        constexpr adaptor_base end_adaptor() const noexcept
        {
            return {};
        }

        template<typename D>
        static constexpr adaptor_cursor_t<D> begin_cursor_(D & d) noexcept(noexcept(
            adaptor_cursor_t<D>{std::declval<detail::begin_adaptor_t<D> &>().begin(d),
                                range_access::begin_adaptor(d)}))
        {
            auto adapt = range_access::begin_adaptor(d);
            auto pos = adapt.begin(d);
            return {std::move(pos), std::move(adapt)};
        }
         template<typename D = Derived > requires same_as<D, Derived>
#line 506 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        constexpr auto begin_cursor() noexcept(
            noexcept(view_adaptor::begin_cursor_(std::declval<D &>())))
            -> decltype(view_adaptor::begin_cursor_(std::declval<D &>()))
        {
            return view_adaptor::begin_cursor_(derived());
        }
         template<typename D = Derived > requires same_as<D, Derived> && range<base_range_t const>
#line 514 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        constexpr auto begin_cursor() const
            noexcept(noexcept(view_adaptor::begin_cursor_(std::declval<D const &>())))
                -> decltype(view_adaptor::begin_cursor_(std::declval<D const &>()))
        {
            return view_adaptor::begin_cursor_(derived());
        }

        template<typename D>
        static constexpr adaptor_sentinel_t<D> end_cursor_(D & d) noexcept(noexcept(
            adaptor_sentinel_t<D>{std::declval<detail::end_adaptor_t<D> &>().end(d),
                                  range_access::end_adaptor(d)}))
        {
            auto adapt = range_access::end_adaptor(d);
            auto pos = adapt.end(d);
            return {std::move(pos), std::move(adapt)};
        }
         template<typename D = Derived > requires same_as<D, Derived>
#line 532 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        constexpr auto end_cursor() noexcept(
            noexcept(view_adaptor::end_cursor_(std::declval<D &>())))
            -> decltype(view_adaptor::end_cursor_(std::declval<D &>()))
        {
            return view_adaptor::end_cursor_(derived());
        }
         template<typename D = Derived > requires same_as<D, Derived> && range<base_range_t const>
#line 540 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
        constexpr auto end_cursor() const noexcept(
            noexcept(view_adaptor::end_cursor_(std::declval<D const &>())))
            -> decltype(view_adaptor::end_cursor_(std::declval<D const &>()))
        {
            return view_adaptor::end_cursor_(derived());
        }

    protected:
        ~view_adaptor() = default;

    public:
        view_adaptor() = default;
        view_adaptor(view_adaptor &&) = default;
        view_adaptor(view_adaptor const &) = default;
        view_adaptor & operator=(view_adaptor &&) = default;
        view_adaptor & operator=(view_adaptor const &) = default;
        constexpr explicit view_adaptor(BaseRng && rng)
          : rng_(views::all(static_cast<BaseRng &&>(rng)))
        {}
        constexpr base_range_t & base() noexcept
        {
            return rng_;
        }
        
        constexpr base_range_t const & base() const noexcept
        {
            return rng_;
        }
    };

    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 574 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"

#line 576 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/adaptor.hpp"
#pragma external_header(pop)
#line 38 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"



#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 42 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"

namespace ranges
{
    
    namespace detail
    {
        constexpr cardinality transform2_cardinality(cardinality c1, cardinality c2)
        {
            return c1 >= 0 || c2 >= 0
                       ? (c1 >= 0 && c2 >= 0 ? (c1 < c2 ? c1 : c2) : finite)
                       : c1 == finite || c2 == finite
                             ? finite
                             : c1 == unknown || c2 == unknown ? unknown : infinite;
        }

        
        
        
         template<typename Fun, typename Rng > concept iter_transform_1_readable_concept_ = regular_invocable<Fun &, iterator_t<Rng>> && regular_invocable<Fun &, copy_tag, iterator_t<Rng>> && regular_invocable<Fun &, move_tag, iterator_t<Rng>> && common_reference_with< invoke_result_t<Fun &, iterator_t<Rng>> &&, invoke_result_t<Fun &, copy_tag, iterator_t<Rng>> &> && common_reference_with< invoke_result_t<Fun &, iterator_t<Rng>> &&, invoke_result_t<Fun &, move_tag, iterator_t<Rng>> &&> && common_reference_with< invoke_result_t<Fun &, move_tag, iterator_t<Rng>> &&, invoke_result_t<Fun &, copy_tag, iterator_t<Rng>> const &>;
#line 75 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        
        
        template<typename Fun, typename Rng>
        concept iter_transform_1_readable =
            detail::iter_transform_1_readable_concept_<Fun, Rng>;

        
        
         template<typename Fun, typename Rng1, typename Rng2 > concept iter_transform_2_readable_concept_ = regular_invocable<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> && regular_invocable<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> && regular_invocable<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> && common_reference_with< invoke_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&, invoke_result_t<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> &> && common_reference_with< invoke_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&, invoke_result_t<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&> && common_reference_with< invoke_result_t<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&, invoke_result_t<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> const &>;
#line 98 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        
        
        template<typename Fun, typename Rng1, typename Rng2>
        concept iter_transform_2_readable =
            detail::iter_transform_2_readable_concept_<Fun, Rng1, Rng2>;
        
    } 
    

    
    
    template<typename Rng, typename Fun>
    struct iter_transform_view : view_adaptor<iter_transform_view<Rng, Fun>, Rng>
    {
    private:
        friend range_access;
         semiregular_box_t<Fun> fun_;
        template<bool Const>
        using use_sentinel_t =
            meta::bool_<!common_range<meta::const_if_c<Const, Rng>> ||
                        single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>>;

        template<bool IsConst>
        struct adaptor : adaptor_base
        {
        private:
            friend struct adaptor<!IsConst>;
            using CRng = meta::const_if_c<IsConst, Rng>;
            using fun_ref_ = semiregular_box_ref_or_val_t<Fun, IsConst>;
             fun_ref_ fun_;

        public:
            using value_type =
                detail::decay_t<invoke_result_t<Fun &, copy_tag, iterator_t<CRng>>>;
            adaptor() = default;
            adaptor(fun_ref_ fun)
              : fun_(std::move(fun))
            {}
             template<bool Other > requires IsConst && (!(Other)) 
#line 138 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            adaptor(adaptor<Other> that)
              : fun_(std::move(that.fun_))
            {}

            
            auto read (iterator_t<CRng> it) const noexcept(noexcept(invoke(fun_, it))) -> decltype(invoke(fun_, it)) { return (invoke(fun_, it)); }
#line 147 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            auto iter_move (iterator_t<CRng> it) const noexcept(noexcept(invoke(fun_, move_tag{}, it))) -> decltype(invoke(fun_, move_tag{}, it)) { return (invoke(fun_, move_tag{}, it)); }
#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            
        };

        adaptor<false> begin_adaptor()
        {
            return {fun_};
        }
         template<bool Const = true > requires Const && range<meta::const_if_c<Const, Rng>> && detail::iter_transform_1_readable<Fun const, meta::const_if_c<Const, Rng>>
#line 162 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        adaptor<Const> begin_adaptor() const
        {
            return {fun_};
        }
        meta::if_<use_sentinel_t<false>, adaptor_base, adaptor<false>> end_adaptor()
        {
            return {fun_};
        }
         template<bool Const = true > requires Const && range<meta::const_if_c<Const, Rng>> && detail::iter_transform_1_readable<Fun const, meta::const_if_c<Const, Rng>>
#line 174 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        meta::if_<use_sentinel_t<Const>, adaptor_base, adaptor<Const>> end_adaptor() const
        {
            return {fun_};
        }

    public:
        iter_transform_view() = default;
        iter_transform_view(Rng rng, Fun fun)
          : iter_transform_view::view_adaptor{std::move(rng)}
          , fun_(std::move(fun))
        {}
        
        constexpr auto size () requires sized_range<Rng>
#line 188 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        {
            return ranges::size(this->base());
        }
        
        constexpr auto size () const requires sized_range<Rng const>
#line 194 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        {
            return ranges::size(this->base());
        }
    };

    template<typename Rng, typename Fun>
    struct transform_view : iter_transform_view<Rng, indirected<Fun>>
    {
        transform_view() = default;
        transform_view(Rng rng, Fun fun)
          : iter_transform_view<Rng, indirected<Fun>>{std::move(rng),
                                                      indirect(std::move(fun))}
        {}
    };


     template<typename Rng, typename Fun > requires copy_constructible<Fun>
#line 212 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
    transform_view(Rng &&, Fun)
        -> transform_view<views::all_t<Rng>, Fun>;
#line 215 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"

    template<typename Rng1, typename Rng2, typename Fun>
    struct iter_transform2_view
      : view_facade<iter_transform2_view<Rng1, Rng2, Fun>,
                    detail::transform2_cardinality(range_cardinality<Rng1>::value,
                                                   range_cardinality<Rng2>::value)>
    {
    private:
        friend range_access;
         semiregular_box_t<Fun> fun_;
        Rng1 rng1_;
        Rng2 rng2_;
        using difference_type_ =
            common_type_t<range_difference_t<Rng1>, range_difference_t<Rng2>>;

        static constexpr cardinality my_cardinality = detail::transform2_cardinality(
            range_cardinality<Rng1>::value, range_cardinality<Rng2>::value);

        template<bool>
        struct cursor;

        template<bool Const>
        struct sentinel
        {
        private:
            friend struct cursor<Const>;
            sentinel_t<meta::const_if_c<Const, Rng1>> end1_;
            sentinel_t<meta::const_if_c<Const, Rng2>> end2_;

        public:
            sentinel() = default;
            sentinel(meta::const_if_c<Const, iter_transform2_view> * parent,
                     decltype(ranges::end))
              : end1_(end(parent->rng1_))
              , end2_(end(parent->rng2_))
            {}
             template<bool Other > requires Const && (!(Other)) 
#line 253 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            sentinel(sentinel<Other> that)
              : end1_(std::move(that.end1_))
              , end2_(std::move(that.end2_))
            {}
        };

        template<bool Const>
        struct cursor
        {
        private:
            using fun_ref_ = semiregular_box_ref_or_val_t<Fun, Const>;
            using R1 = meta::const_if_c<Const, Rng1>;
            using R2 = meta::const_if_c<Const, Rng2>;
            fun_ref_ fun_;
            iterator_t<R1> it1_;
            iterator_t<R2> it2_;

        public:
            using difference_type = difference_type_;
            using single_pass = meta::or_c<(bool)single_pass_iterator_<iterator_t<R1>>,
                                           (bool)single_pass_iterator_<iterator_t<R2>>>;
            using value_type =
                detail::decay_t<invoke_result_t<meta::const_if_c<Const, Fun> &, copy_tag,
                                                iterator_t<R1>, iterator_t<R2>>>;

            cursor() = default;
            template<typename BeginEndFn>
            cursor(meta::const_if_c<Const, iter_transform2_view> * parent,
                   BeginEndFn begin_end)
              : fun_(parent->fun_)
              , it1_(begin_end(parent->rng1_))
              , it2_(begin_end(parent->rng2_))
            {}
             template<bool Other > requires Const && (!(Other)) 
#line 288 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            cursor(cursor<Other> that)
              : fun_(std::move(that.fun_))
              , it1_(std::move(that.end1_))
              , it2_(std::move(that.end2_))
            {}
            
            auto read () const noexcept(noexcept(invoke(fun_, it1_, it2_))) -> decltype(invoke(fun_, it1_, it2_)) { return (invoke(fun_, it1_, it2_)); }
#line 298 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
                
                void next()
            {
                ++it1_;
                ++it2_;
            }
            
            auto equal(cursor const & that) const 
                -> bool requires forward_range<Rng1> && forward_range<Rng2>
#line 308 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            {
                
                
                
                return it1_ == that.it1_ || it2_ == that.it2_;
            }
            bool equal(sentinel<Const> const & s) const
            {
                
                
                
                return it1_ == s.end1_ || it2_ == s.end2_;
            }
            
            auto prev() 
                -> void requires bidirectional_range<R1> && bidirectional_range<R2>
#line 325 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            {
                --it1_;
                --it2_;
            }
            
            auto advance(difference_type n) -> void requires random_access_range<R1> && random_access_range<R2>
#line 332 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            {
                ranges::advance(it1_, n);
                ranges::advance(it2_, n);
            }
            
            auto distance_to(cursor const & that) const 
                -> difference_type requires sized_sentinel_for<iterator_t<R1>, iterator_t<R1>> && sized_sentinel_for<iterator_t<R2>, iterator_t<R2>>
#line 341 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            {
                
                
                difference_type d1 = that.it1_ - it1_, d2 = that.it2_ - it2_;
                return 0 < d1 ? ranges::min(d1, d2) : ranges::max(d1, d2);
            }
            
            auto move () const noexcept(noexcept(invoke(fun_, move_tag{}, it1_, it2_))) -> decltype(invoke(fun_, move_tag{}, it1_, it2_)) { return (invoke(fun_, move_tag{}, it1_, it2_)); }
#line 352 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            
        };

        template<bool Const>
        using end_cursor_t = meta::if_c<
            common_range<meta::const_if_c<Const, Rng1>> &&
                common_range<meta::const_if_c<Const, Rng2>> &&
                !single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng1>>> &&
                !single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng2>>>,
            cursor<Const>, sentinel<Const>>;

        cursor<simple_view<Rng1>() && simple_view<Rng2>()> begin_cursor()
        {
            return {this, ranges::begin};
        }
        end_cursor_t<simple_view<Rng1>() && simple_view<Rng2>()> end_cursor()
        {
            return {this, ranges::end};
        }
         template<bool Const = true > requires Const && range<meta::const_if_c<Const, Rng1>> && range<meta::const_if_c<Const, Rng2>> && detail::iter_transform_2_readable< Fun const, meta::const_if_c<Const, Rng1>, meta::const_if_c<Const, Rng2>>
#line 378 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        cursor<true> begin_cursor() const
        {
            return {this, ranges::begin};
        }
         template<bool Const = true > requires Const && range<meta::const_if_c<Const, Rng1>> && range<meta::const_if_c<Const, Rng2>> && detail::iter_transform_2_readable< Fun const, meta::const_if_c<Const, Rng1>, meta::const_if_c<Const, Rng2>>
#line 389 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        end_cursor_t<Const> end_cursor() const
        {
            return {this, ranges::end};
        }
        template<typename Self>
        static constexpr auto size_(Self & self)
        {
            using size_type = common_type_t<range_size_t<Rng1>, range_size_t<Rng2>>;
            return ranges::min(static_cast<size_type>(ranges::size(self.rng1_)),
                               static_cast<size_type>(ranges::size(self.rng2_)));
        }

        template<bool B>
        using R1 = meta::invoke<detail::dependent_<B>, Rng1>;
        template<bool B>
        using R2 = meta::invoke<detail::dependent_<B>, Rng2>;

    public:
        iter_transform2_view() = default;
        constexpr iter_transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
          : fun_(std::move(fun))
          , rng1_(std::move(rng1))
          , rng2_(std::move(rng2))
        {}
        
        static constexpr auto size() 
            -> std::size_t requires (my_cardinality >= 0)
#line 417 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        {
            return static_cast<std::size_t>(my_cardinality);
        }
         template<bool True = true > requires (my_cardinality < 0) && sized_range<Rng1 const> && sized_range<Rng2 const> && common_with<range_size_t<R1<True>>, range_size_t<R2<True>>>
#line 424 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            constexpr auto size() const
        {
            return size_(*this);
        }
         template<bool True = true > requires (my_cardinality < 0) && sized_range<Rng1> && sized_range<Rng2> && common_with<range_size_t<R1<True>>, range_size_t<R2<True>>>
#line 431 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            constexpr auto size()
        {
            return size_(*this);
        }
    };

    template<typename Rng1, typename Rng2, typename Fun>
    struct transform2_view : iter_transform2_view<Rng1, Rng2, indirected<Fun>>
    {
        transform2_view() = default;
        constexpr transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
          : iter_transform2_view<Rng1, Rng2, indirected<Fun>>{std::move(rng1),
                                                              std::move(rng2),
                                                              indirect(std::move(fun))}
        {}
    };

    namespace views
    {
        struct iter_transform_base_fn
        {
             template<typename Rng, typename Fun > requires viewable_range<Rng> && input_range<Rng> && copy_constructible<Fun> && detail::iter_transform_1_readable<Fun, Rng>
#line 456 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            constexpr iter_transform_view<all_t<Rng>, Fun> 
            operator()(Rng && rng, Fun fun) const
            {
                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
            }

             template<typename Rng1, typename Rng2, typename Fun > requires viewable_range<Rng1> && input_range<Rng1> && viewable_range<Rng2> && input_range<Rng2> && copy_constructible<Fun> && common_with<range_difference_t<Rng1>, range_difference_t<Rng1>> && detail::iter_transform_2_readable<Fun, Rng1, Rng2>
#line 468 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            constexpr iter_transform2_view<all_t<Rng1>, all_t<Rng2>, Fun> 
            operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
            {
                return {all(static_cast<Rng1 &&>(rng1)),
                        all(static_cast<Rng2 &&>(rng2)),
                        std::move(fun)};
            }
        };

        struct iter_transform_fn : iter_transform_base_fn
        {
            using iter_transform_base_fn::operator();

            template<typename Fun>
            constexpr auto operator()(Fun fun) const
            {
                return make_view_closure(
                    bind_back(iter_transform_base_fn{}, std::move(fun)));
            }
        };

        
        
        inline constexpr iter_transform_fn iter_transform{};

        
        
        
        
        
         template<typename Rng, typename Fun > concept transformable_range_concept_ = regular_invocable<Fun &, range_reference_t<Rng>> && (!std::is_void<indirect_result_t<Fun &, iterator_t<Rng>>>::value);
#line 503 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        
        
        template<typename Rng, typename Fun>
        concept transformable_range =
            viewable_range<Rng> && input_range<Rng> &&
            copy_constructible<Fun> &&
            views::transformable_range_concept_<Rng, Fun>;

        
        
         template<typename Rng1, typename Rng2, typename Fun > concept transformable_ranges_concept_ = regular_invocable<Fun &, range_reference_t<Rng1>, range_reference_t<Rng2>> && (!std::is_void< indirect_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>>>::value);
#line 519 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
        
        
        template<typename Rng1, typename Rng2, typename Fun>
        concept transformable_ranges =
            viewable_range<Rng1> && input_range<Rng1> &&
            viewable_range<Rng2> && input_range<Rng2> &&
            copy_constructible<Fun> &&
            views::transformable_ranges_concept_<Rng1, Rng2, Fun>;
        

        struct transform_base_fn
        {
             template<typename Rng, typename Fun > requires transformable_range<Rng, Fun>
#line 533 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            constexpr transform_view<all_t<Rng>, Fun> operator()(Rng && rng, Fun fun)
                const
            {
                return {all(static_cast<Rng &&>(rng)), std::move(fun)};
            }

             template<typename Rng1, typename Rng2, typename Fun > requires transformable_ranges<Rng1, Rng2, Fun>
#line 541 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            constexpr transform2_view<all_t<Rng1>, all_t<Rng2>, Fun> 
            operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
            {
                return {all(static_cast<Rng1 &&>(rng1)),
                        all(static_cast<Rng2 &&>(rng2)),
                        std::move(fun)};
            }
        };

        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        struct transform_fn : transform_base_fn
        {
            using transform_base_fn::operator();

            template<typename Fun>
            constexpr auto operator()(Fun fun) const
            {
                return make_view_closure(bind_back(transform_base_fn{}, std::move(fun)));
            }
        };

        
        
        inline constexpr transform_fn transform{};
    } 

    namespace cpp20
    {
        namespace views
        {
            using ranges::views::transform;
        }
         template<typename Rng, typename F > requires input_range<Rng> && copy_constructible<F> && view_<Rng> && std::is_object<F>::value && regular_invocable<F &, iter_reference_t<iterator_t<Rng>>>
#line 607 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
            using transform_view = ranges::transform_view<Rng, F>;
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 613 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"


namespace boost { template<typename... Ts> struct range_mutable_iterator< ::ranges::iter_transform_view<Ts...>, ::meta::if_c<(bool)::ranges::common_range<::ranges::iter_transform_view<Ts...>>>> { using type = ::ranges::iterator_t<::ranges::iter_transform_view<Ts...>>; }; template<typename... Ts> struct range_const_iterator< ::ranges::iter_transform_view<Ts...>, ::meta::if_c<(bool)::ranges::common_range<::ranges::iter_transform_view<Ts...> const>>> { using type = ::ranges::iterator_t<::ranges::iter_transform_view<Ts...> const>; }; template<typename... Ts> struct range_value<::ranges::iter_transform_view<Ts...>> { using type = ::ranges::range_value_t<::ranges::iter_transform_view<Ts...>>; }; template<typename... Ts> struct range_size<::ranges::iter_transform_view<Ts...>> : ::meta::if_c<(bool)::ranges::common_range<::ranges::iter_transform_view<Ts...>>, ::meta::defer<::ranges::range_size_t, ::ranges::iter_transform_view<Ts...>>, ::meta::nil_> {}; template<typename... Ts> struct range_size<::ranges::iter_transform_view<Ts...> const> : ::meta::if_c<(bool)::ranges::common_range<::ranges::iter_transform_view<Ts...> const>, ::meta::defer<::ranges::range_size_t, ::ranges::iter_transform_view<Ts...> const>, ::meta::nil_> {}; }
namespace boost { template<typename... Ts> struct range_mutable_iterator< ::ranges::transform_view<Ts...>, ::meta::if_c<(bool)::ranges::common_range<::ranges::transform_view<Ts...>>>> { using type = ::ranges::iterator_t<::ranges::transform_view<Ts...>>; }; template<typename... Ts> struct range_const_iterator< ::ranges::transform_view<Ts...>, ::meta::if_c<(bool)::ranges::common_range<::ranges::transform_view<Ts...> const>>> { using type = ::ranges::iterator_t<::ranges::transform_view<Ts...> const>; }; template<typename... Ts> struct range_value<::ranges::transform_view<Ts...>> { using type = ::ranges::range_value_t<::ranges::transform_view<Ts...>>; }; template<typename... Ts> struct range_size<::ranges::transform_view<Ts...>> : ::meta::if_c<(bool)::ranges::common_range<::ranges::transform_view<Ts...>>, ::meta::defer<::ranges::range_size_t, ::ranges::transform_view<Ts...>>, ::meta::nil_> {}; template<typename... Ts> struct range_size<::ranges::transform_view<Ts...> const> : ::meta::if_c<(bool)::ranges::common_range<::ranges::transform_view<Ts...> const>, ::meta::defer<::ranges::range_size_t, ::ranges::transform_view<Ts...> const>, ::meta::nil_> {}; }

#line 619 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/transform.hpp"
#pragma external_header(pop)
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/grammars/schemagrammar.hpp"





namespace Orm::SchemaNs
{
    class BasicCommand;
    class Blueprint;
    class ColumnDefinition;
    class CommandDefinition;
    class ForeignKeyCommand;
    class IndexCommand;
    class TableCommentCommand;

namespace Grammars
{

    
    class __declspec(dllexport) SchemaGrammar : public BaseGrammar
    {
        SchemaGrammar(const SchemaGrammar &) = delete; SchemaGrammar &operator=(const SchemaGrammar &) = delete;

    public:
        
        inline SchemaGrammar() = default;
        
        inline ~SchemaGrammar() override = 0;

        
        virtual bool supportsSchemaTransactions() const noexcept = 0;

        
        
        virtual QString compileCreateDatabase(const QString &name,
                                              DatabaseConnection &connection) const;
        
        virtual QString compileDropDatabaseIfExists(const QString &name) const;

        
        virtual QString compileDropAllTables(const QVector<QString> &tables) const;
        
        virtual QString compileDropAllViews(const QVector<QString> &views) const;

        
        virtual QString compileGetAllTables(const QVector<QString> &databases = {}) const;
        
        virtual QString compileGetAllViews(const QVector<QString> &databases = {}) const;

        
        virtual QString compileEnableForeignKeyConstraints() const = 0;
        
        virtual QString compileDisableForeignKeyConstraints() const = 0;

        
        virtual QString compileTableExists() const;
        
        virtual QString compileColumnListing(const QString &table = "") const = 0;

        
        
        QVector<QString> compileChange(const Blueprint &blueprint,
                                       const BasicCommand &command) const;

        
        QVector<QString> compileDrop(const Blueprint &blueprint,
                                     const BasicCommand &command) const;
        
        QVector<QString> compileDropIfExists(const Blueprint &blueprint,
                                             const BasicCommand &command) const;

        
        virtual QVector<QString>
        compileFullText(const Blueprint &blueprint,
                        const IndexCommand &command) const;

        
        virtual QVector<QString>
        compileForeign(const Blueprint &blueprint,
                       const ForeignKeyCommand &command) const;

        
        virtual QVector<QString>
        compileDropFullText(const Blueprint &blueprint,
                            const IndexCommand &command) const;

        
        virtual QVector<QString>
        compileTableComment(const Blueprint &blueprint,
                            const TableCommentCommand &command) const;

        
        
        QString wrap(const ColumnDefinition &column, bool prefixAlias = false) const;
        
        QString wrapTable(const Blueprint &blueprint) const;
        
        template<ColumnContainer T>
        QVector<QString> prefixArray(const QString &prefix, const T &values) const;

        
        virtual QVector<QString>
        invokeCompileMethod(const CommandDefinition &command,
                            const DatabaseConnection &connection,
                            const Blueprint &blueprint) const = 0;

        
        struct FluentCommandItem
        {
            
            QString commandName;
            
            std::function<bool(const ColumnDefinition &column)> shouldAdd;
        };

        
        virtual const std::vector<FluentCommandItem> &getFluentCommands() const = 0; 

    protected:
        
        virtual QString escapeString(QString value) const = 0;

        
        static bool
        shouldAddAutoIncrementStartingValue(const ColumnDefinition &column) noexcept;

        
        virtual QString getType(ColumnDefinition &column) const = 0;
        
        QStringList getColumns(const Blueprint &blueprint) const;

        
        QString getDefaultValue(const QVariant &value) const;

        
        virtual QString
        addModifiers(QString &&sql, const ColumnDefinition &column) const = 0;

        
        virtual QString typeComputed(const ColumnDefinition &column) const;
    };

    

    SchemaGrammar::~SchemaGrammar() = default;

    

    template<ColumnContainer T>
    QVector<QString>
    SchemaGrammar::prefixArray(const QString &prefix, const T &values) const
    {
        return values
                | ranges::views::transform([&prefix](const auto &value)
        {
            return SPACE_IN.arg(prefix, value);
        })
                | ranges::to<QVector<QString>>();
    }

} 
} 



#line 176 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/grammars/schemagrammar.hpp"
#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemabuilder.hpp"
#pragma once




__pragma(system_header)


#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"
#pragma once




__pragma(system_header)




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignidcolumndefinitionreference.hpp"
#pragma once




__pragma(system_header)


#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinitionreference.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinition.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVariant"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinition.hpp"


#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schematypes.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schematypes.hpp"







namespace Orm::SchemaNs
{

    
    inline constexpr int DefaultStringLength = 255;

    
    enum struct ColumnType
    {
        Undefined = -1,
        Char,
        String,
        TinyText,
        Text,
        MediumText,
        LongText,
        BigInteger,
        Integer,
        MediumInteger,
        TinyInteger,
        SmallInteger,
        Float,
        Double,
        Decimal,
        Real, 
        Boolean,
        Enum,
        Set, 
        Json,
        Jsonb,
        Date,
        DateTime,
        DateTimeTz,
        Time,
        TimeTz,
        Timestamp,
        TimestampTz,
        Year,
        Binary,
        Uuid,
        IpAddress,
        MacAddress,
        Geometry,
        Point,
        LineString,
        Polygon,
        GeometryCollection,
        MultiPoint,
        MultiLineString,
        MultiPolygon,
        MultiPolygonZ, 
        Computed, 
    };

    
    struct AutoIncrementColumnValue
    {
        QString                columnName;
        std::optional<quint64> value;
    };

    

    
    template<typename M>
    concept IsMemFun = std::is_member_function_pointer_v<std::decay_t<M>>;

    
    template<typename Sig>
    struct FunctionSignature;

    
    template<typename R, typename C, typename...Args>
    struct FunctionSignature<R(C::*)(Args...) const>
    {
        using type = std::tuple<Args...>;
    };

    
    template<IsMemFun M>
    auto argumentTypes(M &&) -> typename FunctionSignature<std::decay_t<M>>::type;

    

    template<std::size_t I, IsMemFun M>
    auto argumentType(M &&method) -> decltype (std::get<I>(argumentTypes(method)));

} 



#line 108 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schematypes.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinition.hpp"



namespace Orm::SchemaNs
{

    



    
    using Column = std::variant<QString, Query::Expression>;

    
    class CommandDefinition
    {};

    
    class BasicCommand : public CommandDefinition
    {
    public:
        
        QString name {};
    };

    
    class DropColumnsCommand : public CommandDefinition
    {
    public:
        
        QString name {};

        
        QVector<Column> columns;
    };

    
    class RenameCommand : public CommandDefinition
    {
    public:
        
        QString name {};

        
        QString from {};
        
        QString to;
    };

    
    class IndexCommand : public CommandDefinition
    {
    public:
        
        QString name {};

        
        QString index;
        
        QVector<Column> columns;
        
        QString algorithm {};
        
        QString language {};
    };

    
    class ForeignKeyCommand : public CommandDefinition
    {
    public:
        
        QString name {};

        
        QString index;
        
        QVector<Column> columns;

        
        QVector<QString> references {};
        
        QString on {};
        

        QString onDelete {};
        

        QString onUpdate {};

        
        std::optional<bool> deferrable = std::nullopt;
        
        std::optional<bool> initiallyImmediate = std::nullopt;
        

        std::optional<bool> notValid = std::nullopt;
    };

    
    class CommentCommand : public CommandDefinition
    {
    public:
        
        QString name {};
        
        QString column;
        
        QString comment;
        
        bool change = false;
    };

    
    class AutoIncrementStartingValueCommand : public CommandDefinition
    {
    public:
        
        QString name {};
        
        QString column;
        
        quint64 startingValue;
    };

    
    class TableCommentCommand : public CommandDefinition
    {
    public:
        
        QString name {};
        
        QString comment;
    };

    
    class ColumnDefinition
    {
    public:
        
        
        
        ColumnType type = ColumnType::Undefined;
        
        QString name {};
        
        bool change = false;

        
        
        QVector<QString> allowed {};
        
        QString expression {};
        
        int length = DefaultStringLength;
        
        std::optional<int> places = std::nullopt;
        
        std::optional<int> precision = std::nullopt;
        


        

        std::optional<quint32> srid = std::nullopt;
        
        std::optional<int> total    = std::nullopt;

        
        
        std::variant<std::monostate, QString, bool> index        {};
        
        std::variant<std::monostate, QString, bool> primary      {};
        
        std::variant<std::monostate, QString, bool> fulltext     {};
        
        std::variant<std::monostate, QString, bool> spatialIndex {};
        
        std::variant<std::monostate, QString, bool> unique       {};

        
        
        QString after         {};
        
        QString charset       {};
        
        QString collation     {};
        
        QString comment       {};
        
        QVariant defaultValue {};
        
        QVariant onUpdate     {};
        
        QString generatedAs   {};
        
        QString renameTo      {};

        

        std::optional<quint64> from          = std::nullopt;
        
        std::optional<bool> nullable         = std::nullopt; 
        
        std::optional<quint64> startingValue = std::nullopt;
        
        std::optional<QString> storedAs      = std::nullopt; 
        
        std::optional<QString> virtualAs     = std::nullopt; 

        
        
        bool always             = false;
        
        bool autoIncrement      = false;
        
        bool first              = false;
        
        bool invisible          = false;
        

        bool isGeometry         = false;
        
        bool isUnsigned         = false;
        
        bool useCurrent         = false;
        
        bool useCurrentOnUpdate = false;
    };

    
















} 



#line 263 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinition.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinitionreference.hpp"



namespace Orm::SchemaNs
{

    class ForeignIdColumnDefinitionReference;

    

    template<typename T>
    concept ColumnReferenceReturn = std::is_void_v<T> ||
                                    std::same_as<T, ForeignIdColumnDefinitionReference>;

    

    template<ColumnReferenceReturn R = void>
    class ColumnDefinitionReference
    {
        
        friend ForeignIdColumnDefinitionReference;

    public:
        
        using ColumnReferenceType =
                std::conditional_t<std::is_void_v<R>, ColumnDefinitionReference, R>;

        
        ColumnDefinitionReference(ColumnDefinition &columnDefinition); 
        
        inline ~ColumnDefinitionReference() = default;

        
        inline ColumnDefinitionReference(
                    const ColumnDefinitionReference &) = default;
        
        inline ColumnDefinitionReference(
                    ColumnDefinitionReference &&) noexcept = default;

        
        ColumnDefinitionReference &operator=(const ColumnDefinitionReference &) = delete;
        
        ColumnDefinitionReference &operator=(ColumnDefinitionReference &&) = delete;

        
        ColumnReferenceType &after(QString column);
        
        ColumnReferenceType &always();
        
        ColumnReferenceType &autoIncrement();
        
        ColumnReferenceType &change();
        
        ColumnReferenceType &charset(QString charset);
        
        ColumnReferenceType &collation(QString collation);
        
        ColumnReferenceType &comment(QString comment);
        
        ColumnReferenceType &defaultValue(QVariant value);
        
        ColumnReferenceType &first();
        

        ColumnReferenceType &from(int startingValue);
        
        ColumnReferenceType &generatedAs(QString expression = "");
        
        ColumnReferenceType &invisible();
        

        ColumnReferenceType &isGeometry();
        
        ColumnReferenceType &isUnsigned();
        
        ColumnReferenceType &nullable(bool value = true);
        

        ColumnReferenceType &projection(quint32 value);
        
        ColumnReferenceType &renameTo(QString columnName);
        

        ColumnReferenceType &srid(quint32 value);
        
        ColumnReferenceType &startingValue(int startingValue);
        


        ColumnReferenceType &storedAs(QString expression);
        
        ColumnReferenceType &Unsigned();
        
        ColumnReferenceType &useCurrent();
        
        ColumnReferenceType &useCurrentOnUpdate();
        


        ColumnReferenceType &virtualAs(QString expression);

        
        ColumnReferenceType &index(QString indexName = "");
        
        ColumnReferenceType &primary();
        
        ColumnReferenceType &fulltext(QString indexName = "");
        
        ColumnReferenceType &spatialIndex(QString indexName = "");
        
        ColumnReferenceType &unique(QString indexName = "");

    protected:
        
        std::reference_wrapper<ColumnDefinition> m_columnDefinition;

    private:
        
        inline ColumnReferenceType &columnReference() noexcept;
    };

    













    

    template<ColumnReferenceReturn R>
    ColumnDefinitionReference<R>::ColumnDefinitionReference(
        ColumnDefinition &columnDefinition
    )
        : m_columnDefinition(columnDefinition)
    {}

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::after(QString column)
    {
        m_columnDefinition.get().after = std::move(column);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::always()
    {
        m_columnDefinition.get().always = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::autoIncrement()
    {
        m_columnDefinition.get().autoIncrement = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::change()
    {
        m_columnDefinition.get().change = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::charset(QString charset)
    {
        m_columnDefinition.get().charset = std::move(charset);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::collation(QString collation)
    {
        m_columnDefinition.get().collation = std::move(collation);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::comment(QString comment)
    {
        m_columnDefinition.get().comment = std::move(comment);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::defaultValue(QVariant value)
    {
        m_columnDefinition.get().defaultValue = std::move(value);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::first()
    {
        m_columnDefinition.get().first = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::from(const int startingValue)
    {
        m_columnDefinition.get().from = startingValue;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::generatedAs(QString expression)
    {
        m_columnDefinition.get().generatedAs = std::move(expression);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::invisible()
    {
        m_columnDefinition.get().invisible = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
            ColumnDefinitionReference<R>::isGeometry()
    {
        m_columnDefinition.get().isGeometry = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::isUnsigned()
    {
        m_columnDefinition.get().isUnsigned = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::nullable(const bool value)
    {
        m_columnDefinition.get().nullable = value;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::projection(const quint32 value)
    {
        m_columnDefinition.get().srid = value;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::renameTo(QString columnName)
    {
        m_columnDefinition.get().renameTo = std::move(columnName);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::startingValue(const int startingValue)
    {
        m_columnDefinition.get().startingValue = startingValue;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::srid(const quint32 value)
    {
        m_columnDefinition.get().srid = value;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::storedAs(QString expression)
    {
        m_columnDefinition.get().storedAs = std::move(expression);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::Unsigned()
    {
        m_columnDefinition.get().isUnsigned = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::useCurrent()
    {
        m_columnDefinition.get().useCurrent = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::useCurrentOnUpdate()
    {
        m_columnDefinition.get().useCurrentOnUpdate = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::virtualAs(QString expression)
    {
        m_columnDefinition.get().virtualAs = std::move(expression);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::index(QString indexName)
    {
        if (indexName.isEmpty())
            m_columnDefinition.get().index = true;
        else
            m_columnDefinition.get().index = std::move(indexName);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::primary()
    {
        m_columnDefinition.get().primary = true;

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::fulltext(QString indexName)
    {
        if (indexName.isEmpty())
            m_columnDefinition.get().fulltext = true;
        else
            m_columnDefinition.get().fulltext = std::move(indexName);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::spatialIndex(QString indexName)
    {
        if (indexName.isEmpty())
            m_columnDefinition.get().spatialIndex = true;
        else
            m_columnDefinition.get().spatialIndex = std::move(indexName);

        return columnReference();
    }

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::unique(QString indexName)
    {
        if (indexName.isEmpty())
            m_columnDefinition.get().unique = true;
        else
            m_columnDefinition.get().unique = std::move(indexName);

        return columnReference();
    }

    

    template<ColumnReferenceReturn R>
    typename ColumnDefinitionReference<R>::ColumnReferenceType &
    ColumnDefinitionReference<R>::columnReference() noexcept
    {
        return static_cast<ColumnDefinitionReference<R>::ColumnReferenceType &>(*this);
    }

} 



#line 440 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/columndefinitionreference.hpp"
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignidcolumndefinitionreference.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignkeydefinitionreference.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QVector"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignkeydefinitionreference.hpp"






namespace Orm::SchemaNs
{

    class ForeignKeyCommand;

    

    class __declspec(dllexport) ForeignKeyDefinitionReference
    {
    public:
        
        ForeignKeyDefinitionReference(ForeignKeyCommand &foreignKeyCommandDefinition); 

        
        ForeignKeyDefinitionReference &references(const QVector<QString> &columns);
        
        template<typename = void>
        ForeignKeyDefinitionReference &references(const QString &column);

        
        ForeignKeyDefinitionReference &on(const QString &table);

        
        ForeignKeyDefinitionReference &onDelete(const QString &action);
        
        ForeignKeyDefinitionReference &onUpdate(const QString &action);

        
        ForeignKeyDefinitionReference &deferrable(bool value = true);
        
        ForeignKeyDefinitionReference &initiallyImmediate(bool value = true);
        

        ForeignKeyDefinitionReference &notValid(bool value = true);

        
        
        ForeignKeyDefinitionReference &cascadeOnUpdate();
        
        ForeignKeyDefinitionReference &restrictOnUpdate();
        
        ForeignKeyDefinitionReference &cascadeOnDelete();
        
        ForeignKeyDefinitionReference &restrictOnDelete();
        
        ForeignKeyDefinitionReference &nullOnDelete();

    private:
        
        std::reference_wrapper<ForeignKeyCommand> m_foreignKeyCommandDefinition;
    };

    

    template<typename>
    ForeignKeyDefinitionReference &
    ForeignKeyDefinitionReference::references(const QString &column)
    {
        return references(QVector<QString> {column});
    }

} 



#line 81 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignkeydefinitionreference.hpp"
#line 11 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignidcolumndefinitionreference.hpp"



namespace Orm::SchemaNs
{

    class Blueprint;

    

    class __declspec(dllexport) ForeignIdColumnDefinitionReference :
            public ColumnDefinitionReference<ForeignIdColumnDefinitionReference>
    {
    public:
        
        ForeignIdColumnDefinitionReference( 
                Blueprint &blueprint,
                ColumnDefinitionReference<> columnDefinitionReference);
        
        inline ~ForeignIdColumnDefinitionReference() = default;

        
        inline ForeignIdColumnDefinitionReference(
                    const ForeignIdColumnDefinitionReference &) = default;
        
        inline ForeignIdColumnDefinitionReference(
                    ForeignIdColumnDefinitionReference &&) noexcept = default;

        
        ForeignIdColumnDefinitionReference &
        operator=(const ForeignIdColumnDefinitionReference &) = delete;
        
        ForeignIdColumnDefinitionReference &
        operator=(ForeignIdColumnDefinitionReference &&) = delete;

        

        ForeignKeyDefinitionReference
        constrained(const QString &table = Orm::Constants::EMPTY,
                    const QString &column = Orm::Constants::ID);

        
        ForeignKeyDefinitionReference references(const QVector<QString> &columns);
        
        template<typename = void>
        ForeignKeyDefinitionReference references(const QString &column);

    private:
        
        std::reference_wrapper<Blueprint> m_blueprint;
        
        std::optional<ForeignKeyDefinitionReference>
                m_foreignKeyDefinitionReference = std::nullopt;
    };

    template<typename>
    ForeignKeyDefinitionReference
    ForeignIdColumnDefinitionReference::references(const QString &column)
    {
        return references(QVector<QString> {column});
    }

} 



#line 78 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/foreignidcolumndefinitionreference.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/indexdefinitionreference.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/indexdefinitionreference.hpp"






namespace Orm::SchemaNs
{
    class IndexCommand;

    

    class __declspec(dllexport) IndexDefinitionReference
    {
    public:
        
        IndexDefinitionReference(IndexCommand &indexCommand); 
        
        inline ~IndexDefinitionReference() = default;

        
        inline IndexDefinitionReference(
                    const IndexDefinitionReference &) = default;
        
        inline IndexDefinitionReference(
                    IndexDefinitionReference &&) noexcept = default;

        
        IndexDefinitionReference &
        operator=(const IndexDefinitionReference &) = delete;
        
        IndexDefinitionReference &
        operator=(IndexDefinitionReference &&) = delete;

        
        constexpr const IndexCommand &get() const noexcept;
        
        constexpr operator const IndexCommand &() const noexcept; 

        
        IndexDefinitionReference &algorithm(const QString &algorithm);
        
        IndexDefinitionReference &language(const QString &language);

    private:
        
        std::reference_wrapper<IndexCommand> m_indexCommand;
    };

    

    constexpr const IndexCommand &IndexDefinitionReference::get() const noexcept
    {
        return m_indexCommand.get();
    }

    constexpr IndexDefinitionReference::operator const IndexCommand &() const noexcept
    {
        return get();
    }

} 



#line 75 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/indexdefinitionreference.hpp"
#line 13 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants.hpp"
#pragma once




__pragma(system_header)




#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants_extern.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants_extern.hpp"







namespace Orm::SchemaNs
{
namespace Constants
{

    
    __declspec(dllexport) extern const QString Create;
    __declspec(dllexport) extern const QString Add;
    __declspec(dllexport) extern const QString Change;
    __declspec(dllexport) extern const QString Rename;
    __declspec(dllexport) extern const QString Drop;
    __declspec(dllexport) extern const QString DropIfExists;
    __declspec(dllexport) extern const QString DropColumn;
    __declspec(dllexport) extern const QString RenameColumn;
    __declspec(dllexport) extern const QString DropPrimary;
    __declspec(dllexport) extern const QString DropUnique;
    __declspec(dllexport) extern const QString DropIndex;
    __declspec(dllexport) extern const QString DropFullText;
    __declspec(dllexport) extern const QString DropSpatialIndex;
    __declspec(dllexport) extern const QString DropForeign;
    __declspec(dllexport) extern const QString RenameIndex;

    
    __declspec(dllexport) extern const QString Comment;

    
    __declspec(dllexport) extern const QString AutoIncrementStartingValue;
    __declspec(dllexport) extern const QString TableComment;

    
    __declspec(dllexport) extern const QString Primary;
    __declspec(dllexport) extern const QString Unique;
    __declspec(dllexport) extern const QString Index;
    __declspec(dllexport) extern const QString Fulltext;
    __declspec(dllexport) extern const QString SpatialIndex;
    __declspec(dllexport) extern const QString Foreign;

    
    __declspec(dllexport) extern const QString Cascade;
    __declspec(dllexport) extern const QString Restrict;
    __declspec(dllexport) extern const QString SetNull;

    
    __declspec(dllexport) extern const QString integer_;
    __declspec(dllexport) extern const QString varchar_;
    __declspec(dllexport) extern const QString float_;

    
    __declspec(dllexport) extern const QString TRIM_QUOTES;

} 


using namespace Orm::SchemaNs::Constants;

} 



#line 76 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants_extern.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants.hpp"


#line 15 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants.hpp"

#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemaconstants.hpp"
#line 14 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"
#pragma once




__pragma(system_header)









#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"



#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinyconcepts.hpp"
#pragma once




__pragma(system_header)










namespace Orm::Tiny
{

    

    template<typename Derived, typename ...AllRelations>
    concept AllRelationsConcept = (!std::same_as<Derived, AllRelations> && ...);

    class IsModel;

    
    template<typename T>
    concept ModelConcept = std::derived_from<T, IsModel> &&
                           std::derived_from<T, typename T::BaseModelType>;

    
    template<typename T>
    concept DerivedCollectionModel =
            
            (!std::is_reference_v<T> && !std::is_const_v<T>) &&
             
            ((std::is_pointer_v<T> &&
              std::derived_from<std::remove_pointer_t<T>, IsModel> &&
              std::derived_from<std::remove_pointer_t<T>,
                                typename std::remove_pointer_t<T>::BaseModelType>) ||
             
             
             !std::is_pointer_v<T>);

    

    template<typename T, typename U>
    concept SameDerivedCollectionModel = DerivedCollectionModel<T> &&
                                         DerivedCollectionModel<U> &&
                                         std::same_as<std::remove_pointer_t<T>, U>;
    

    struct AttributeItem;

    
    template<typename C>
    concept SerializedAttributes = std::same_as<C, QVariantMap> ||
                                   std::same_as<C, QVector<AttributeItem>>;

    
    template<typename C>
    concept HasReserveMethod = requires(C c)
    {
        typename C::size_type;
        



#line 71 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinyconcepts.hpp"
        requires std::same_as<typename C::size_type, std::size_t> ||
                 std::same_as<typename C::size_type, int>;
#line 74 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinyconcepts.hpp"
        { c.reserve(typename C::size_type()) } -> std::same_as<void>;
    };

} 



#line 82 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinyconcepts.hpp"
#line 21 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"



namespace Orm
{
namespace Tiny
{
namespace Relations
{
    template<class Model, class Related>
    class Relation;
}
namespace Types
{
    template<DerivedCollectionModel Model>
    class ModelsCollection;
}

    template<typename Model>
    class Builder;

    
    template<typename Model>
    using TinyBuilder = Builder<Model>;

    template<typename Derived, AllRelationsConcept ...AllRelations>
    class Model;

    
    template<typename Model>
    using ModelsCollection = Types::ModelsCollection<Model>;

    
    template<AllRelationsConcept ...AllRelations>
    using RelationsType = std::variant<std::monostate,
                                       ModelsCollection<AllRelations>...,
                                       std::optional<AllRelations>...>;





    template<AllRelationsConcept ...AllRelations>
    using RelationsContainer = std::unordered_map<QString,
                                                  RelationsType<AllRelations...>>;
#line 67 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"

    
    
    struct __declspec(dllexport) AttributeItem
    {
        QString  key   {};
        QVariant value {};

        
        explicit operator UpdateItem() const;
    };

    
    __declspec(dllexport) bool
    operator==(const AttributeItem &left, const AttributeItem &right);

    
    struct __declspec(dllexport) WithItem
    {
        QString name;
        std::function<void(QueryBuilder &)> constraints = nullptr;

        
        static QVector<WithItem> fromStringVector(const QVector<QString> &relations);
        
        static QVector<WithItem> fromStringVector(QVector<QString> &&relations);
    };

    
    [[maybe_unused]]
    __declspec(dllexport) bool operator==(const WithItem &left, const WithItem &right);

    

    struct One {};

    


    struct Many {};

    
    struct SaveOptions
    {
        
        bool touch = true;
    };

    
    class IsModel
    {};

    
    struct DontFillDefaultAttributes
    {
        
        inline DontFillDefaultAttributes() = default;
    };

    

    inline constexpr DontFillDefaultAttributes dontFillDefaultAttributes {};

    
    enum struct CastType
    {
        
        Bool, Boolean,
        
        Short,
        UShort,
        
        Int,  Integer,
        UInt, UInteger,
        
        LongLong,
        ULongLong,
        
        Real, Float,  Double,
        Decimal,
        
        QString,
        
        QDate,
        QDateTime,
        Timestamp,
        CustomQDate,
        CustomQDateTime,
        
        QByteArray,
    };

    
    class CastItem
    {
    public:
        
        inline CastItem(CastType castType, QVariant modifier = {}) noexcept; 

        
        inline bool operator==(const CastItem &) const = default;

        
        
        inline CastType type() const noexcept;
        
        inline const QVariant &modifier() const noexcept;

    private:
        
        CastType m_type;
        
        QVariant m_modifier;
    };

    

    

    CastItem::CastItem(const CastType castType, QVariant modifier) noexcept
        : m_type(castType)
        , m_modifier(std::move(modifier))
    {}

    

    CastType CastItem::type() const noexcept
    {
        return m_type;
    }

    const QVariant &CastItem::modifier() const noexcept
    {
        return m_modifier;
    }

namespace Concerns
{
    
    template<typename Related>
    using QueriesRelationshipsCallback =
            std::conditional_t<std::is_void_v<Related>, QueryBuilder,
                               TinyBuilder<Related>>;
} 
} 

    
    using One = Tiny::One;

} 






 template <> struct QMetaTypeId< ::Orm::Tiny::AttributeItem > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< ::Orm::Tiny::AttributeItem >("::Orm::Tiny::AttributeItem", reinterpret_cast< ::Orm::Tiny::AttributeItem *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };  


#line 227 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"
#line 228 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"

#line 230 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/tiny/tinytypes.hpp"
#line 16 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"
#line 17 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"



namespace Orm
{
    class DatabaseConnection;

namespace SchemaNs
{
namespace Grammars
{
    class SchemaGrammar;
}

    
    template<typename T>
    concept CommandDefinitionConcept = std::derived_from<T, CommandDefinition>;

    
    class __declspec(dllexport) Blueprint
    {
        Blueprint(const Blueprint &) = delete; Blueprint &operator=(const Blueprint &) = delete;

        
        using Expression    = Query::Expression;
        
        using SchemaGrammar = Grammars::SchemaGrammar;

    public:
        
        explicit Blueprint(QString table,
                           const std::function<void(Blueprint &)> &callback = nullptr,
                           QString &&prefix = "");
        
        inline ~Blueprint() = default;

        
        void build(DatabaseConnection &connection, const SchemaGrammar &grammar);
        
        QVector<QString>
        toSql(const DatabaseConnection &connection, const SchemaGrammar &grammar);

        
        const BasicCommand &create();
        
        void after(const QString &column,
                   const std::function<void(Blueprint &)> &callback);
        
        const BasicCommand &drop();
        
        const BasicCommand &dropIfExists();

        
        const DropColumnsCommand &dropColumns(const QVector<QString> &columns);
        
        template<QStringConcept ...Args>
        const DropColumnsCommand &dropColumns(Args &&...columns);
        
        const DropColumnsCommand &dropColumn(const QString &column);

        
        void dropTimestamps();
        
        inline void dropTimestampsTz();
        
        inline void dropDatetimes();

        
        inline void dropSoftDeletes(const QString &column = Orm::Constants::DELETED_AT);
        
        inline void dropSoftDeletesTz(const QString &column = Orm::Constants::DELETED_AT);
        
        inline void
        dropSoftDeletesDatetime(const QString &column = Orm::Constants::DELETED_AT);

        
        inline void dropRememberToken();

        
        const RenameCommand &rename(const QString &to);

        
        const RenameCommand &renameColumn(const QString &from, const QString &to);

        
        IndexDefinitionReference
        primary(const QVector<QString> &columns, const QString &indexName = "",
                const QString &algorithm = "");
        
        template<typename = void>
        IndexDefinitionReference
        primary(const QString &column, const QString &indexName = "",
                const QString &algorithm = "");
        
        IndexDefinitionReference
        unique(const QVector<QString> &columns, const QString &indexName = "",
               const QString &algorithm = "");
        
        template<typename = void>
        IndexDefinitionReference
        unique(const QString &column, const QString &indexName = "",
               const QString &algorithm = "");
        
        IndexDefinitionReference
        index(const QVector<QString> &columns, const QString &indexName = "",
              const QString &algorithm = "");
        
        template<typename = void>
        IndexDefinitionReference
        index(const QString &column, const QString &indexName = "",
              const QString &algorithm = "");
        
        IndexDefinitionReference
        fullText(const QVector<QString> &columns, const QString &indexName = "",
                 const QString &algorithm = "", const QString &language = "");
        
        template<typename = void>
        IndexDefinitionReference
        fullText(const QString &column, const QString &indexName = "",
                 const QString &algorithm = "", const QString &language = "");
        
        IndexDefinitionReference
        spatialIndex(const QVector<QString> &columns, const QString &indexName = "");
        
        template<typename = void>
        IndexDefinitionReference
        spatialIndex(const QString &column, const QString &indexName = "");
        
        IndexDefinitionReference
        rawIndex(const Expression &expression, const QString &indexName);
        
        ForeignKeyDefinitionReference
        foreign(const QVector<QString> &columns, const QString &indexName = "");
        
        template<typename = void>
        ForeignKeyDefinitionReference
        foreign(const QString &column, const QString &indexName = "");

        
        const IndexCommand &dropPrimary(const QVector<QString> &columns = {});
        
        const IndexCommand &dropUnique(const QVector<QString> &columns);
        
        const IndexCommand &dropIndex(const QVector<QString> &columns);
        
        const IndexCommand &dropFullText(const QVector<QString> &columns);
        
        const IndexCommand &dropSpatialIndex(const QVector<QString> &columns);
        
        const IndexCommand &dropForeign(const QVector<QString> &columns);
        
        const DropColumnsCommand &dropConstrainedForeignId(const QString &column);

        
        template<typename = void>
        const IndexCommand &dropPrimary(const QString &indexName = "");
        
        template<typename = void>
        const IndexCommand &dropUnique(const QString &indexName);
        
        template<typename = void>
        const IndexCommand &dropIndex(const QString &indexName);
        
        template<typename = void>
        const IndexCommand &dropFullText(const QString &indexName);
        
        template<typename = void>
        const IndexCommand &dropSpatialIndex(const QString &indexName);
        
        template<typename = void>
        const IndexCommand &dropForeign(const QString &indexName);

        
        const RenameCommand &renameIndex(const QString &from, const QString &to);

        
        inline ColumnDefinitionReference<> id(const QString &column = Orm::Constants::ID);

        
        ForeignIdColumnDefinitionReference foreignId(const QString &column);

        
        template<Tiny::ModelConcept Model>
        ForeignIdColumnDefinitionReference foreignIdFor(const Model &model,
                                                        const QString &column = "");
#line 203 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"
        
        ForeignIdColumnDefinitionReference foreignUuid(const QString &column);

        
        inline ColumnDefinitionReference<> increments(const QString &column);
        
        inline ColumnDefinitionReference<> integerIncrements(const QString &column);
        
        inline ColumnDefinitionReference<> tinyIncrements(const QString &column);
        
        inline ColumnDefinitionReference<> smallIncrements(const QString &column);
        
        inline ColumnDefinitionReference<> mediumIncrements(const QString &column);
        
        inline ColumnDefinitionReference<> bigIncrements(const QString &column);

        
        ColumnDefinitionReference<>
        integer(const QString &column, bool autoIncrement = false,
                bool isUnsigned = false);
        
        ColumnDefinitionReference<>
        tinyInteger(const QString &column, bool autoIncrement = false,
                    bool isUnsigned = false);
        
        ColumnDefinitionReference<>
        smallInteger(const QString &column, bool autoIncrement = false,
                     bool isUnsigned = false);
        
        ColumnDefinitionReference<>
        mediumInteger(const QString &column, bool autoIncrement = false,
                      bool isUnsigned = false);
        
        ColumnDefinitionReference<>
        bigInteger(const QString &column, bool autoIncrement = false,
                   bool isUnsigned = false);

        
        inline ColumnDefinitionReference<>
        unsignedInteger(const QString &column, bool autoIncrement = false);
        
        inline ColumnDefinitionReference<>
        unsignedTinyInteger(const QString &column, bool autoIncrement = false);
        
        inline ColumnDefinitionReference<>
        unsignedSmallInteger(const QString &column, bool autoIncrement = false);
        
        inline ColumnDefinitionReference<>
        unsignedMediumInteger(const QString &column, bool autoIncrement = false);
        
        inline ColumnDefinitionReference<>
        unsignedBigInteger(const QString &column, bool autoIncrement = false);

        
        ColumnDefinitionReference<>
        Char(const QString &column, int length = DefaultStringLength);

        
        ColumnDefinitionReference<> string(const QString &column,
                                           int length = DefaultStringLength);
        
        ColumnDefinitionReference<> tinyText(const QString &column);
        
        ColumnDefinitionReference<> text(const QString &column);
        
        ColumnDefinitionReference<> mediumText(const QString &column);
        
        ColumnDefinitionReference<> longText(const QString &column);

        
        ColumnDefinitionReference<>
        Float(const QString &column, std::optional<int> total = 8,
              std::optional<int> places = 2, bool isUnsigned = false);
        
        ColumnDefinitionReference<>
        Double(const QString &column, std::optional<int> total = std::nullopt,
               std::optional<int> places = std::nullopt, bool isUnsigned = false);
        
        ColumnDefinitionReference<>
        decimal(const QString &column, std::optional<int> total = 8,
                std::optional<int> places = 2, bool isUnsigned = false);

        
        inline ColumnDefinitionReference<>
        unsignedFloat(const QString &column, std::optional<int> total = 8,
                      std::optional<int> places = 2);
        
        inline ColumnDefinitionReference<>
        unsignedDouble(const QString &column, std::optional<int> total = std::nullopt,
                       std::optional<int> places = std::nullopt);
        
        inline ColumnDefinitionReference<>
        unsignedDecimal(const QString &column, std::optional<int> total = 8,
                        std::optional<int> places = 2);

        
        ColumnDefinitionReference<> boolean(const QString &column);

        
        ColumnDefinitionReference<> Enum(const QString &column,
                                         const QVector<QString> &allowed);
        
        ColumnDefinitionReference<> set(const QString &column,
                                        const QVector<QString> &allowed);

        
        ColumnDefinitionReference<> json(const QString &column);
        
        ColumnDefinitionReference<> jsonb(const QString &column);

        
        ColumnDefinitionReference<> date(const QString &column);
        
        ColumnDefinitionReference<> datetime(const QString &column,
                                             std::optional<int> precision = 0);
        
        ColumnDefinitionReference<> datetimeTz(const QString &column,
                                               std::optional<int> precision = 0);

        
        ColumnDefinitionReference<> time(const QString &column,
                                         std::optional<int> precision = 0);
        
        ColumnDefinitionReference<> timeTz(const QString &column,
                                           std::optional<int> precision = 0);

        
        ColumnDefinitionReference<> timestamp(const QString &column,
                                              std::optional<int> precision = 0);
        
        ColumnDefinitionReference<> timestampTz(const QString &column,
                                                std::optional<int> precision = 0);

        
        void timestamps(std::optional<int> precision = 0);
        
        void timestampsTz(std::optional<int> precision = 0);

        
        inline void datetimes(std::optional<int> precision = 0);

        
        ColumnDefinitionReference<>
        softDeletes(const QString &column = Orm::Constants::DELETED_AT,
                    std::optional<int> precision = 0);
        
        ColumnDefinitionReference<>
        softDeletesTz(const QString &column = Orm::Constants::DELETED_AT,
                      std::optional<int> precision = 0);

        
        inline ColumnDefinitionReference<>
        softDeletesDatetime(const QString &column = Orm::Constants::DELETED_AT,
                            std::optional<int> precision = 0);

        
        ColumnDefinitionReference<> year(const QString &column);

        
        ColumnDefinitionReference<> binary(const QString &column);

        
        ColumnDefinitionReference<>
        uuid(const QString &column = ([]() noexcept -> QString { enum { Size = sizeof(u"" "uuid")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "uuid" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()));

        
        ColumnDefinitionReference<>
        ipAddress(const QString &column = ([]() noexcept -> QString { enum { Size = sizeof(u"" "ip_address")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ip_address" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()));
        
        ColumnDefinitionReference<>
        macAddress(const QString &column = ([]() noexcept -> QString { enum { Size = sizeof(u"" "mac_address")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mac_address" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }()));

        
        ColumnDefinitionReference<> geometry(const QString &column);
        
        ColumnDefinitionReference<> point(const QString &column,
                                          std::optional<quint32> srid = std::nullopt);
        
        ColumnDefinitionReference<> lineString(const QString &column);
        
        ColumnDefinitionReference<> polygon(const QString &column);
        
        ColumnDefinitionReference<> geometryCollection(const QString &column);
        
        ColumnDefinitionReference<> multiPoint(const QString &column);
        
        ColumnDefinitionReference<> multiLineString(const QString &column);
        
        ColumnDefinitionReference<> multiPolygon(const QString &column);
        
        ColumnDefinitionReference<> multiPolygonZ(const QString &column);

        
        ColumnDefinitionReference<> computed(const QString &column,
                                             const QString &expression);

        
        ColumnDefinitionReference<> rememberToken();

        
        const TableCommentCommand &comment(QString comment);

        
        ColumnDefinitionReference<> addColumn(ColumnType type, const QString &name,
                                              ColumnDefinition &&definition = {});

        
        
        QVector<ColumnDefinition> getAddedColumns() const;
        
        QVector<ColumnDefinition> getChangedColumns() const;

        
        bool creating() const;

        
        Blueprint &removeColumn(const QString &name);

        
        
        inline const QString &getTable() const noexcept;
        
        inline const QVector<ColumnDefinition> &getColumns() const noexcept;
        
        inline const std::deque<std::shared_ptr<CommandDefinition>> &
        getCommands() const noexcept;
        
        inline bool isTemporary() const noexcept;

        
        
        inline void temporary() noexcept;

        
        static void defaultStringLength(int length) noexcept;

        
        static int DefaultStringLength;

        
        QString engine {};
        
        QString charset {};
        
        QString collation {};

    protected:
        


        
        ColumnDefinitionReference<> addColumnDefinition(ColumnDefinition &&definition);

        
        template<CommandDefinitionConcept T = BasicCommand>
        T &addCommand(T &&definition = {});
        
        template<CommandDefinitionConcept T>
        std::shared_ptr<T> createCommand(T &&definition = {});

        
        void addImpliedCommands(const SchemaGrammar &grammar);
        
        void addFluentIndexes();
        
        void addFluentCommands(const SchemaGrammar &grammar);

        
        IndexDefinitionReference
        indexCommand(const QString &type, const QVector<QString> &columns,
                     const QString &indexName, const QString &algorithm = "",
                     const QString &language = "");
        
        const IndexCommand &
        dropIndexCommand(const QString &command, const QString &type,
                         const QVector<QString> &columns);
        
        const IndexCommand &
        dropIndexCommand(const QString &command, const QString &indexName);

        
        QString createIndexName(const QString &type,
                                const QVector<QString> &columns) const;

        
        QString m_table;
        
        QString m_prefix;

        
        QVector<ColumnDefinition> m_columns {};
        
        std::deque<std::shared_ptr<CommandDefinition>> m_commands {};

        
        bool m_temporary = false;
        
        QString m_after {};
    };

    


    template<Tiny::ModelConcept Model>
    ForeignIdColumnDefinitionReference
    Blueprint::foreignIdFor(const Model &model, const QString &column)
    {
        const auto column_ = column.isEmpty() ? model.getForeignKey() : column;

        
        return std::is_integral_v<typename Model::KeyType> && model.getIncrementing()
                ? foreignId(column_)
                : foreignUuid(column_);
    }
#line 518 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"

    template<QStringConcept ...Args>
    const DropColumnsCommand &Blueprint::dropColumns(Args &&...columns)
    {
        return dropColumns(QVector<QString> {std::forward<Args>(columns)...});
    }

    void Blueprint::dropTimestampsTz()
    {
        dropTimestamps();
    }

    void Blueprint::dropDatetimes()
    {
        dropTimestamps();
    }

    void Blueprint::dropSoftDeletes(const QString &column)
    {
        dropColumns(QVector<QString> {column});
    }

    void Blueprint::dropSoftDeletesTz(const QString &column)
    {
        dropSoftDeletes(column);
    }

    void Blueprint::dropSoftDeletesDatetime(const QString &column)
    {
        dropSoftDeletes(column);
    }

    void Blueprint::dropRememberToken()
    {
        dropColumns({([]() noexcept -> QString { enum { Size = sizeof(u"" "remember_token")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "remember_token" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }())});
    }

    template<typename>
    IndexDefinitionReference
    Blueprint::primary(const QString &column, const QString &indexName,
                       const QString &algorithm)
    {
        return primary(QVector<QString> {column}, indexName, algorithm);
    }

    template<typename>
    IndexDefinitionReference
    Blueprint::unique(const QString &column, const QString &indexName,
                      const QString &algorithm)
    {
        return unique(QVector<QString> {column}, indexName, algorithm);
    }

    template<typename>
    IndexDefinitionReference
    Blueprint::index(const QString &column, const QString &indexName,
                     const QString &algorithm)
    {
        return index(QVector<QString> {column}, indexName, algorithm);
    }

    template<typename>
    IndexDefinitionReference
    Blueprint::fullText(const QString &column, const QString &indexName,
                        const QString &algorithm, const QString &language)
    {
        return fullText(QVector<QString> {column}, indexName, algorithm, language);
    }

    template<typename>
    IndexDefinitionReference
    Blueprint::spatialIndex(const QString &column, const QString &indexName)
    {
        return spatialIndex(QVector<QString> {column}, indexName);
    }

    template<typename>
    ForeignKeyDefinitionReference
    Blueprint::foreign(const QString &column, const QString &indexName)
    {
        return foreign(QVector<QString> {column}, indexName);
    }

    template<typename>
    const IndexCommand &Blueprint::dropPrimary(const QString &indexName)
    {
        return dropIndexCommand(DropPrimary, indexName);
    }

    template<typename>
    const IndexCommand &Blueprint::dropUnique(const QString &indexName)
    {
        return dropIndexCommand(DropUnique, indexName);
    }

    template<typename>
    const IndexCommand &Blueprint::dropIndex(const QString &indexName)
    {
        return dropIndexCommand(DropIndex, indexName);
    }

    template<typename>
    const IndexCommand &Blueprint::dropFullText(const QString &indexName)
    {
        return dropIndexCommand(DropFullText, indexName);
    }

    template<typename>
    const IndexCommand &Blueprint::dropSpatialIndex(const QString &indexName)
    {
        return dropIndexCommand(DropSpatialIndex, indexName);
    }

    template<typename>
    const IndexCommand &Blueprint::dropForeign(const QString &indexName)
    {
        return dropIndexCommand(DropForeign, indexName);
    }

    ColumnDefinitionReference<> Blueprint::id(const QString &column)
    {
        return bigIncrements(column);
    }

    ColumnDefinitionReference<> Blueprint::increments(const QString &column)
    {
        return unsignedInteger(column, true);
    }

    ColumnDefinitionReference<> Blueprint::integerIncrements(const QString &column)
    {
        return unsignedInteger(column, true);
    }

    ColumnDefinitionReference<> Blueprint::tinyIncrements(const QString &column)
    {
        return unsignedTinyInteger(column, true);
    }

    ColumnDefinitionReference<> Blueprint::smallIncrements(const QString &column)
    {
        return unsignedSmallInteger(column, true);
    }

    ColumnDefinitionReference<> Blueprint::mediumIncrements(const QString &column)
    {
        return unsignedMediumInteger(column, true);
    }

    ColumnDefinitionReference<> Blueprint::bigIncrements(const QString &column)
    {
        return unsignedBigInteger(column, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedInteger(const QString &column, const bool autoIncrement)
    {
        return integer(column, autoIncrement, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedTinyInteger(const QString &column, const bool autoIncrement)
    {
        return tinyInteger(column, autoIncrement, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedSmallInteger(const QString &column, const bool autoIncrement)
    {
        return smallInteger(column, autoIncrement, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedMediumInteger(const QString &column, const bool autoIncrement)
    {
        return mediumInteger(column, autoIncrement, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedBigInteger(const QString &column, const bool autoIncrement)
    {
        return bigInteger(column, autoIncrement, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedFloat(const QString &column, const std::optional<int> total,
                             const std::optional<int> places)
    {
        return Float(column, total, places, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedDouble(const QString &column, const std::optional<int> total,
                              const std::optional<int> places)
    {
        return Double(column, total, places, true);
    }

    ColumnDefinitionReference<>
    Blueprint::unsignedDecimal(const QString &column, const std::optional<int> total,
                               const std::optional<int> places)
    {
        return decimal(column, total, places, true);
    }

    void Blueprint::datetimes(const std::optional<int> precision)
    {
        datetime(Orm::Constants::CREATED_AT, precision).nullable();

        datetime(Orm::Constants::UPDATED_AT, precision).nullable();
    }

    ColumnDefinitionReference<>
    Blueprint::softDeletesDatetime(const QString &column,
                                   const std::optional<int> precision)
    {
        return datetime(column, precision).nullable();
    }

    const QString &Blueprint::getTable() const noexcept
    {
        return m_table;
    }

    const QVector<ColumnDefinition> &Blueprint::getColumns() const noexcept
    {
        return m_columns;
    }

    const std::deque<std::shared_ptr<CommandDefinition>> &
    Blueprint::getCommands() const noexcept
    {
        return m_commands;
    }

    bool Blueprint::isTemporary() const noexcept
    {
        return m_temporary;
    }

    void Blueprint::temporary() noexcept
    {
        m_temporary = true;
    }

    

    template<CommandDefinitionConcept T>
    T &Blueprint::addCommand(T &&definition)
    {
        auto command = createCommand(std::forward<T>(definition));

        m_commands.emplace_back(std::move(command));

        return reinterpret_cast<T &>(*m_commands.back());
    }

    template<CommandDefinitionConcept T>
    std::shared_ptr<T>
    Blueprint::createCommand(T &&definition)
    {
        return std::make_shared<T>(std::forward<T>(definition));
    }

} 
} 



#line 788 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/blueprint.hpp"
#line 10 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemabuilder.hpp"





namespace Orm
{
    class DatabaseConnection;

namespace SchemaNs
{
namespace Grammars
{
    class SchemaGrammar;
}

    
    class __declspec(dllexport) SchemaBuilder
    {
        SchemaBuilder(const SchemaBuilder &) = delete; SchemaBuilder &operator=(const SchemaBuilder &) = delete;

        
        using Helpers = Orm::Utils::Helpers;

    public:
        
        explicit SchemaBuilder(std::shared_ptr<DatabaseConnection> connection);
        
        inline virtual ~SchemaBuilder() = default;

        
        virtual std::optional<SqlQuery>
        createDatabase(const QString &name) const;
        
        virtual std::optional<SqlQuery>
        dropDatabaseIfExists(const QString &name) const;

        
        void create(const QString &table,
                    const std::function<void(Blueprint &)> &callback) const;
        
        void table(const QString &table,
                   const std::function<void(Blueprint &)> &callback) const;

        
        void drop(const QString &table) const;
        
        void dropIfExists(const QString &table) const;

        
        void rename(const QString &from, const QString &to) const;

        
        void dropColumns(const QString &table, const QVector<QString> &columns) const;
        
        template<QStringConcept ...Args>
        void dropColumns(const QString &table, Args &&...columns);
        
        void dropColumn(const QString &table, const QString &column) const;

        
        void renameColumn(const QString &table, const QString &from, const QString &to);

        
        virtual void dropAllTables() const;
        
        virtual void dropAllViews() const;
        
        virtual void dropAllTypes() const;

        
        virtual SqlQuery getAllTables() const;
        
        virtual SqlQuery getAllViews() const;

        
        SqlQuery enableForeignKeyConstraints() const;
        
        SqlQuery disableForeignKeyConstraints() const;
        
        void withoutForeignKeyConstraints(const std::function<void()> &callback) const;

        
        virtual QStringList getColumnListing(const QString &table) const;

        
        virtual bool hasTable(const QString &table) const;
        
        bool hasColumn(const QString &table, const QString &column) const;
        
        bool hasColumns(const QString &table, const QVector<QString> &columns) const;

        
        
        inline DatabaseConnection &getConnection();
        
        inline const DatabaseConnection &getConnection() const;

    protected:
        using SchemaGrammar = Grammars::SchemaGrammar;

        
        Blueprint
        createBlueprint(const QString &table,
                        const std::function<void(Blueprint &)> &callback = nullptr) const;
        
        void build(Blueprint &&blueprint) const;

        
        std::shared_ptr<DatabaseConnection> m_connection;
        
        std::shared_ptr<SchemaGrammar> m_grammar;
    };

    

    template<QStringConcept ...Args>
    void SchemaBuilder::dropColumns(const QString &table, Args &&...columns)
    {
        dropColumns(table, {std::forward<Args>(columns)...});
    }

    DatabaseConnection &SchemaBuilder::getConnection()
    {
        return *m_connection;
    }

    const DatabaseConnection &SchemaBuilder::getConnection() const
    {
        return *m_connection;
    }

} 
} 



#line 148 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/schema/schemabuilder.hpp"
#line 18 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"




namespace Orm
{

    
    using QueryGrammar   = Query::Grammars::Grammar;
    
    using QueryProcessor = Query::Processors::Processor;
    
    using SchemaBuilder  = SchemaNs::SchemaBuilder;
    
    using SchemaGrammar  = SchemaNs::Grammars::SchemaGrammar;




#line 38 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
    







    class __declspec(dllexport) DatabaseConnection :
            public Concerns::DetectsLostConnections,
            public Concerns::ManagesTransactions,
            public Concerns::LogsQueries,
            public Concerns::CountsQueries,
            
            public std::enable_shared_from_this<DatabaseConnection>
    {
        DatabaseConnection(const DatabaseConnection &) = delete; DatabaseConnection &operator=(const DatabaseConnection &) = delete;

        
        friend Concerns::ManagesTransactions;
        







    protected:
        
        explicit DatabaseConnection(
                std::function<Connectors::ConnectionName()> &&connection,
                QString &&database = "", QString &&tablePrefix = "",
                QtTimeZoneConfig &&qtTimeZone = {QtTimeZoneType::QtTimeSpec, Qt::UTC},
                QVariantHash &&config = {});
        
        explicit DatabaseConnection(
                std::function<Connectors::ConnectionName()> &&connection,
                QString &&database = "", QString &&tablePrefix = "",
                QtTimeZoneConfig &&qtTimeZone = {QtTimeZoneType::QtTimeSpec, Qt::UTC},
                std::optional<bool> returnQDateTime = true,
                QVariantHash &&config = {});

    public:
        
        inline ~DatabaseConnection() override = 0;

        
        std::shared_ptr<QueryBuilder>
        table(const QString &table, const QString &as = "");

        
        inline QString getTablePrefix() const;
        
        DatabaseConnection &setTablePrefix(const QString &prefix);
        
        BaseGrammar &withTablePrefix(BaseGrammar &grammar) const;

        
        std::shared_ptr<QueryBuilder> query();

        
        inline Query::Expression raw(const QVariant &value) const;
        
        inline Query::Expression raw(QVariant &&value) const noexcept;

        
        
        SqlQuery
        select(const QString &queryString, QVector<QVariant> bindings = {});
        
        inline SqlQuery
        selectFromWriteConnection(const QString &queryString,
                                  QVector<QVariant> bindings = {});

        
        SqlQuery
        selectOne(const QString &queryString, QVector<QVariant> bindings = {});
        
        QVariant
        scalar(const QString &queryString, QVector<QVariant> bindings = {});

        
        inline SqlQuery
        insert(const QString &queryString, QVector<QVariant> bindings = {});
        
        inline std::tuple<int, QSqlQuery>
        update(const QString &queryString, QVector<QVariant> bindings = {});
        
        inline std::tuple<int, QSqlQuery>
        remove(const QString &queryString, QVector<QVariant> bindings = {});

        

        SqlQuery statement(const QString &queryString, QVector<QVariant> bindings = {});
        
        std::tuple<int, QSqlQuery>
        affectingStatement(const QString &queryString, QVector<QVariant> bindings = {});

        
        SqlQuery unprepared(const QString &queryString);

        
        
        QSqlDatabase getQtConnection();
        
        QSqlDatabase getRawQtConnection() const;
        
        inline const std::function<Connectors::ConnectionName()> &
        getQtConnectionResolver() const noexcept;
        
        DatabaseConnection &setQtConnectionResolver(
                const std::function<Connectors::ConnectionName()> &resolver);

        
        QSqlQuery getQtQuery();

        
        QVector<QVariant> &prepareBindings(QVector<QVariant> &bindings) const;
        
        static void bindValues(QSqlQuery &query, const QVector<QVariant> &bindings);

        
        inline bool isOpen();
        
        virtual bool pingDatabase();

        
        QSqlDriver *driver();

        

        inline void connectEagerly();
        

        void reconnectIfMissingConnection() const;
        

        void reconnect() const;
        
        void disconnect();

        
        inline const QueryGrammar &getQueryGrammar() const noexcept;
        
        inline QueryGrammar &getQueryGrammar() noexcept;
        
        inline const SchemaGrammar &getSchemaGrammar();
        
        SchemaBuilder &getSchemaBuilder();
        
        inline const QueryProcessor &getPostProcessor() const noexcept;

        
        inline std::shared_ptr<QueryGrammar> getQueryGrammarShared() const noexcept;
        
        std::shared_ptr<SchemaGrammar> getSchemaGrammarShared();

        
        DatabaseConnection &setReconnector(const ReconnectorType &reconnector);

        
        
        QVariant getConfig(const QString &option) const;
        
        inline const QVariantHash &getConfig() const noexcept;
        
        bool hasConfig(const QString &option) const;

        
        
        QString driverName();
        
        const QString &driverNamePrintable();
        
        inline const QString &getName() const noexcept;
        
        inline const QString &getDatabaseName() const noexcept;
        
        inline const QString &getHostName() const noexcept;

        
        inline const QtTimeZoneConfig &getQtTimeZone() const noexcept;
        
        DatabaseConnection &setQtTimeZone(const QVariant &timezone);
        
        DatabaseConnection &setQtTimeZone(QtTimeZoneConfig &&timezone) noexcept;
        
        inline bool isConvertingTimeZone() const noexcept;

        
        
        QVector<Log>
        pretend(const std::function<void()> &callback);
        
        QVector<Log>
        pretend(const std::function<void(DatabaseConnection &)> &callback);
        
        inline bool pretending() const;

        
        inline bool getRecordsHaveBeenModified() const;
        
        inline void recordsHaveBeenModified(bool value = true);
        
        inline void forgetRecordModificationState();

    protected:
        
        void useDefaultQueryGrammar();
        
        void useDefaultSchemaGrammar();
        
        void useDefaultSchemaBuilder();
        
        void useDefaultPostProcessor();

        
        virtual std::unique_ptr<QueryGrammar> getDefaultQueryGrammar() const = 0;
        
        virtual std::unique_ptr<SchemaGrammar> getDefaultSchemaGrammar() = 0;
        
        virtual std::unique_ptr<SchemaBuilder> getDefaultSchemaBuilder() = 0;
        
        virtual std::unique_ptr<QueryProcessor> getDefaultPostProcessor() const = 0;

        
        template<typename Return>
        using RunCallback =
                std::function<Return(const QString &, const QVector<QVariant> &)>;

        
        template<typename Return>
        Return run(
                const QString &queryString, QVector<QVariant> &&bindings,
                const QString &type, const RunCallback<Return> &callback);
        
        template<typename Return>
        Return runQueryCallback(
                const QString &queryString, const QVector<QVariant> &preparedBindings,
                const RunCallback<Return> &callback) const;

        
        std::optional<Connectors::ConnectionName> m_qtConnection = std::nullopt;
        
        std::function<Connectors::ConnectionName()> m_qtConnectionResolver;
        
         QString m_database;
        
        QString m_tablePrefix;
        
        QtTimeZoneConfig m_qtTimeZone;
        
        bool m_isConvertingTimeZone;
        
        std::optional<bool> m_returnQDateTime = std::nullopt;
        
         QVariantHash m_config;
        
        ReconnectorType m_reconnector = nullptr;

        
        std::shared_ptr<QueryGrammar> m_queryGrammar = nullptr;
        
        std::shared_ptr<SchemaGrammar> m_schemaGrammar = nullptr;
        
        std::unique_ptr<SchemaBuilder> m_schemaBuilder = nullptr;
        
        std::unique_ptr<QueryProcessor> m_postProcessor = nullptr;

        
        
        bool m_pretending = false;

    private:
        
        QSqlQuery prepareQuery(const QString &queryString);
        
        inline static QSqlQuery getQtQueryForPretend();

        
        QDateTime prepareBinding(const QDateTime &binding) const;

        
        template<typename Return>
        Return handleQueryException(
                const std::exception_ptr &ePtr, const Exceptions::QueryError &e,
                const QString &queryString, const QVector<QVariant> &preparedBindings,
                const RunCallback<Return> &callback) const;
        
        template<typename Return>
        Return tryAgainIfCausedByLostConnection(
                const std::exception_ptr &ePtr, const Exceptions::QueryError &e,
                const QString &queryString, const QVector<QVariant> &preparedBindings,
                const RunCallback<Return> &callback) const;

        
        inline bool shouldCountElapsed() const;

        
        void logConnected();
        
        void logDisconnected();

        
        bool m_disconnectedLogged = false;
        
        bool m_connectedLogged = false;

        
        QString m_connectionName;
        
        QString m_hostName;

        
        std::optional<std::reference_wrapper<const QString>>
        m_driverNamePrintable = std::nullopt;
    };


#line 359 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"

    

    DatabaseConnection::~DatabaseConnection() = default;

    QString DatabaseConnection::getTablePrefix() const
    {
        return m_tablePrefix;
    }

    Query::Expression
    DatabaseConnection::raw(const QVariant &value) const 
    {
        return Query::Expression(value);
    }

    Query::Expression
    DatabaseConnection::raw(QVariant &&value) const noexcept 
    {
        return Query::Expression(std::move(value));
    }

    

    SqlQuery
    DatabaseConnection::selectFromWriteConnection(const QString &queryString,
                                                  QVector<QVariant> bindings)
    {
        
        
        return select(queryString, std::move(bindings));
    }

    SqlQuery
    DatabaseConnection::insert(const QString &queryString, QVector<QVariant> bindings)
    {
        return statement(queryString, std::move(bindings));
    }

    std::tuple<int, QSqlQuery>
    DatabaseConnection::update(const QString &queryString, QVector<QVariant> bindings)
    {
        return affectingStatement(queryString, std::move(bindings));
    }

    std::tuple<int, QSqlQuery>
    DatabaseConnection::remove(const QString &queryString, QVector<QVariant> bindings)
    {
        return affectingStatement(queryString, std::move(bindings));
    }

    

    const std::function<Connectors::ConnectionName()> &
    DatabaseConnection::getQtConnectionResolver() const noexcept
    {
        return m_qtConnectionResolver;
    }

    bool DatabaseConnection::isOpen()
    {
        return m_qtConnection && getQtConnection().isOpen();
    }

    void DatabaseConnection::connectEagerly()
    {
        reconnectIfMissingConnection();

        
        std::ignore = getQtConnection();
    }

    const QueryGrammar &DatabaseConnection::getQueryGrammar() const noexcept
    {
        return *m_queryGrammar;
    }

    QueryGrammar &DatabaseConnection::getQueryGrammar() noexcept
    {
        return *m_queryGrammar;
    }

    const SchemaGrammar &DatabaseConnection::getSchemaGrammar()
    {
        return *getSchemaGrammarShared();
    }

    const QueryProcessor &DatabaseConnection::getPostProcessor() const noexcept
    {
        return *m_postProcessor;
    }

    std::shared_ptr<QueryGrammar>
    DatabaseConnection::getQueryGrammarShared() const noexcept
    {
        return m_queryGrammar;
    }

    const QVariantHash &DatabaseConnection::getConfig() const noexcept
    {
        return m_config;
    }

    

    const QString &DatabaseConnection::getName() const noexcept
    {
        return m_connectionName;
    }

    const QString &DatabaseConnection::getDatabaseName() const noexcept
    {
        return m_database;
    }

    const QString &DatabaseConnection::getHostName() const noexcept
    {
        return m_hostName;
    }

    const QtTimeZoneConfig &DatabaseConnection::getQtTimeZone() const noexcept
    {
        return m_qtTimeZone;
    }

    bool DatabaseConnection::isConvertingTimeZone() const noexcept
    {
        return m_isConvertingTimeZone;
    }

    

    bool DatabaseConnection::pretending() const
    {
        return m_pretending;
    }

    bool DatabaseConnection::getRecordsHaveBeenModified() const
    {
        return m_recordsModified;
    }

    void DatabaseConnection::recordsHaveBeenModified(const bool value)
    {
        m_recordsModified = value;
    }

    void DatabaseConnection::forgetRecordModificationState()
    {
        m_recordsModified = false;
    }

    

    template<typename Return>
    Return
    DatabaseConnection::run(
            const QString &queryString, QVector<QVariant> &&bindings,
            const QString &type, const RunCallback<Return> &callback)
    {
        reconnectIfMissingConnection();

        
        const auto countElapsed = shouldCountElapsed();

        QElapsedTimer timer;
        if (countElapsed)
            timer.start();

        Return result;

        


        const auto &preparedBindings = prepareBindings(bindings);

        


        try {
            result = runQueryCallback(queryString, preparedBindings, callback);

        }  catch (const Exceptions::QueryError &e) {
            result = handleQueryException(std::current_exception(), e,
                                          queryString, preparedBindings, callback);
        }

        std::optional<qint64> elapsed;
        if (countElapsed) {
            
            elapsed = timer.elapsed();

            
            m_elapsedCounter += *elapsed;
        }

        


        if (m_pretending)
            logQueryForPretend(queryString, preparedBindings, type);
        else
            logQuery(result, elapsed, type);

        return result;
    }

    template<typename Return>
    Return
    DatabaseConnection::runQueryCallback(
            const QString &queryString, const QVector<QVariant> &preparedBindings,
            const RunCallback<Return> &callback) const
    {
        


        return std::invoke(callback, queryString, preparedBindings);
    }

    

    QSqlQuery DatabaseConnection::getQtQueryForPretend()
    {
        return QSqlQuery(QSqlDatabase());
    }

    template<typename Return>
    Return
    DatabaseConnection::handleQueryException(
            const std::exception_ptr &ePtr, const Exceptions::QueryError &e,
            const QString &queryString, const QVector<QVariant> &preparedBindings,
            const RunCallback<Return> &callback) const
    {
        
        if (inTransaction())
            std::rethrow_exception(ePtr);

        return tryAgainIfCausedByLostConnection(ePtr, e, queryString, preparedBindings,
                                                callback);
    }

    template<typename Return>
    Return
    DatabaseConnection::tryAgainIfCausedByLostConnection(
            const std::exception_ptr &ePtr, const Exceptions::QueryError &e,
            const QString &queryString, const QVector<QVariant> &preparedBindings,
            const RunCallback<Return> &callback) const
    {
        
        if (causedByLostConnection(e)) {
            reconnect();

            
            

            return runQueryCallback(queryString, preparedBindings, callback);
        }

        std::rethrow_exception(ePtr);
    }

    bool DatabaseConnection::shouldCountElapsed() const
    {
        return !m_pretending && (m_debugSql || m_countingElapsed);
    }

} 



#line 630 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databaseconnection.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconnectionsmap.hpp"




namespace Orm::Support
{

    
    class DatabaseConnectionsMap
    {
        DatabaseConnectionsMap(const DatabaseConnectionsMap &) = delete; DatabaseConnectionsMap &operator=(const DatabaseConnectionsMap &) = delete;

    public:
        
        inline DatabaseConnectionsMap() = default;
        
        inline ~DatabaseConnectionsMap() = default;

        
        using ConnectionsType =
                std::unordered_map<QString, std::shared_ptr<DatabaseConnection>>;

        
        inline ConnectionsType *operator->() noexcept;
        
        inline const ConnectionsType *operator->() const noexcept;
        
        inline ConnectionsType &operator*() noexcept;
        
        inline const ConnectionsType &operator*() const noexcept;
        
        inline ConnectionsType &get() noexcept;
        
        inline const ConnectionsType &get() const noexcept;

    private:
        
        thread_local
        inline static ConnectionsType m_connections;
    };

    

    DatabaseConnectionsMap::ConnectionsType *
    DatabaseConnectionsMap::operator->() noexcept
    {
        return std::addressof(m_connections);
    }

    const DatabaseConnectionsMap::ConnectionsType *
    DatabaseConnectionsMap::operator->() const noexcept
    {
        return std::addressof(m_connections);
    }

    DatabaseConnectionsMap::ConnectionsType &
    DatabaseConnectionsMap::operator*() noexcept
    {
        return m_connections;
    }

    const DatabaseConnectionsMap::ConnectionsType &
    DatabaseConnectionsMap::operator*() const noexcept
    {
        return m_connections;
    }

    DatabaseConnectionsMap::ConnectionsType &
    DatabaseConnectionsMap::get() noexcept 
    {
        return m_connections;
    }

    const DatabaseConnectionsMap::ConnectionsType &
    DatabaseConnectionsMap::get() const noexcept 
    {
        return m_connections;
    }

} 



#line 93 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/support/databaseconnectionsmap.hpp"
#line 12 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"



namespace Orm
{
namespace Query
{
    class Builder;
}

    
    class __declspec(dllexport) DatabaseManager final : public ConnectionResolverInterface
    {
        DatabaseManager(const DatabaseManager &) = delete; DatabaseManager &operator=(const DatabaseManager &) = delete;

        
        using Configuration = Orm::Support::DatabaseConfiguration;

    public:
        
        using ConfigurationsType = Configuration::ConfigurationsType;

        
        ~DatabaseManager() final;

        
        

        static std::shared_ptr<DatabaseManager>
        create(const QString &defaultConnection = Configuration::defaultConnectionName);
        

        static std::shared_ptr<DatabaseManager>
        create(const QVariantHash &config,
               const QString &connection = Configuration::defaultConnectionName);
        

        static std::shared_ptr<DatabaseManager>
        create(const ConfigurationsType &configs,
               const QString &defaultConnection = Configuration::defaultConnectionName);

        
        
        inline Query::Expression raw(const QVariant &value) const;
        
        inline Query::Expression raw(QVariant &&value) const noexcept;

        
        
        std::shared_ptr<QueryBuilder>
        table(const QString &table, const QString &connection = "");
        
        std::shared_ptr<QueryBuilder>
        tableAs(const QString &table, const QString &as = "",
                const QString &connection = "");

        
        std::shared_ptr<QueryBuilder> query(const QString &connection = "");
        
        QSqlQuery qtQuery(const QString &connection = "");

        
        
        SqlQuery
        select(const QString &query, QVector<QVariant> bindings = {},
               const QString &connection = "");
        
        SqlQuery
        selectFromWriteConnection(const QString &query, QVector<QVariant> bindings = {},
                                  const QString &connection = "");

        
        SqlQuery
        selectOne(const QString &query, QVector<QVariant> bindings = {},
                  const QString &connection = "");
        
        QVariant
        scalar(const QString &query, QVector<QVariant> bindings = {},
               const QString &connection = "");

        
        SqlQuery
        insert(const QString &query, QVector<QVariant> bindings = {},
               const QString &connection = "");
        
        std::tuple<int, QSqlQuery>
        update(const QString &query, QVector<QVariant> bindings = {},
               const QString &connection = "");
        
        std::tuple<int, QSqlQuery>
        remove(const QString &query, QVector<QVariant> bindings = {},
               const QString &connection = "");

        
        SqlQuery
        statement(const QString &query, QVector<QVariant> bindings = {},
                  const QString &connection = "");
        
        std::tuple<int, QSqlQuery>
        affectingStatement(const QString &query, QVector<QVariant> bindings = {},
                           const QString &connection = "");

        
        SqlQuery unprepared(const QString &query, const QString &connection = "");

        
        bool beginTransaction(const QString &connection = "");
        
        bool commit(const QString &connection = "");
        
        bool rollBack(const QString &connection = "");
        
        bool savepoint(const QString &id, const QString &connection = "");
        
        bool savepoint(std::size_t id, const QString &connection = "");
        
        bool rollbackToSavepoint(const QString &id, const QString &connection = "");
        
        bool rollbackToSavepoint(std::size_t id, const QString &connection = "");
        
        std::size_t transactionLevel(const QString &connection = "");

        
        bool isOpen(const QString &connection = "");
        
        bool pingDatabase(const QString &connection = "");

        
        QSqlDriver *driver(const QString &connection = "");

        
        
        static std::shared_ptr<DatabaseManager> instance();
        
        static DatabaseManager &reference();

        
        DatabaseConnection &connection(const QString &name = "") final;
        

        inline DatabaseConnection &on(const QString &connection);
        
        DatabaseManager &
        addConnection(const QVariantHash &config,
                      const QString &name = Configuration::defaultConnectionName);
        
        DatabaseManager &
        addConnections(const ConfigurationsType &configs);
        
        DatabaseManager &
        addConnections(const ConfigurationsType &configs,
                       const QString &defaultConnection);
        
        bool removeConnection(const QString &name = "");
        
        bool containsConnection(const QString &name = "");

        
        DatabaseConnection &reconnect(const QString &name = "");
        
        void disconnect(const QString &name = "") const;
        

        void connectEagerly(const QString &name = "");

        
        QStringList connectionNames() const;
        
        QStringList openedConnectionNames() const;
        
        std::size_t openedConnectionsSize() const noexcept;

        
        QStringList supportedDrivers() const;
        
        QStringList drivers() const;
        
        bool isDriverAvailable(const QString &driverName) const;
        
        bool isConnectionDriverAvailable(const QString &connection);

        
        const QString &getDefaultConnection() const noexcept final;
        
        void setDefaultConnection(const QString &defaultConnection) final;
        
        void resetDefaultConnection() final;

        
        DatabaseManager &setReconnector(const ReconnectorType &reconnector);

        
        
        QString driverName(const QString &connection = "");
        
        const QString &driverNamePrintable(const QString &connection = "");
        
        const QString &databaseName(const QString &connection = "");
        
        const QString &hostName(const QString &connection = "");

        
        const QtTimeZoneConfig &
        qtTimeZone(const QString &connection = "");
        
        DatabaseConnection &
        setQtTimeZone(const QVariant &timezone, const QString &connection = "");
        
        DatabaseConnection &
        setQtTimeZone(QtTimeZoneConfig &&timezone, const QString &connection = "");
        
        bool isConvertingTimeZone(const QString &connection = "");

        
        

        QVariant originalConfigValue(const QString &option,
                                     const QString &connection = "") const;
        

        const QVariantHash &originalConfig(const QString &connection = "") const;
        
        std::size_t originalConfigsSize() const;

        
        
        QVariant getConfigValue(const QString &option, const QString &connection = "");
        
        const QVariantHash &getConfig(const QString &connection = "");
        
        bool hasConfigValue(const QString &option, const QString &connection = "");

        
        
        QVector<Log>
        pretend(const std::function<void()> &callback,
                const QString &connection = "");
        
        QVector<Log>
        pretend(const std::function<void(DatabaseConnection &)> &callback,
                const QString &connection = "");

        
        
        bool getRecordsHaveBeenModified(const QString &connection = "");
        
        void recordsHaveBeenModified(bool value = true,
                                     const QString &connection = "");
        
        void forgetRecordModificationState(const QString &connection = "");

        
        
        std::shared_ptr<QVector<Log>>
        getQueryLog(const QString &connection = "");
        
        void flushQueryLog(const QString &connection = "");
        
        void enableQueryLog(const QString &connection = "");
        
        void disableQueryLog(const QString &connection = "");
        
        bool logging(const QString &connection = "");
        
        std::size_t getQueryLogOrder() const noexcept;

        
        
        bool countingElapsed(const QString &connection = "");
        
        DatabaseConnection &enableElapsedCounter(const QString &connection = "");
        
        DatabaseConnection &disableElapsedCounter(const QString &connection = "");
        
        qint64 getElapsedCounter(const QString &connection = "");
        
        qint64 takeElapsedCounter(const QString &connection = "");
        
        DatabaseConnection &resetElapsedCounter(const QString &connection = "");

        
        bool anyCountingElapsed();
        
        void enableAllElapsedCounters();
        
        void disableAllElapsedCounters();
        
        qint64 getAllElapsedCounters();
        
        qint64 takeAllElapsedCounters();
        
        void resetAllElapsedCounters();

        
        void enableElapsedCounters(const QStringList &connections);
        
        void disableElapsedCounters(const QStringList &connections);
        
        qint64 getElapsedCounters(const QStringList &connections);
        
        qint64 takeElapsedCounters(const QStringList &connections);
        
        void resetElapsedCounters(const QStringList &connections);

        
        
        bool countingStatements(const QString &connection = "");
        
        DatabaseConnection &
        enableStatementsCounter(const QString &connection = "");
        
        DatabaseConnection &
        disableStatementsCounter(const QString &connection = "");
        
        const StatementsCounter &
        getStatementsCounter(const QString &connection = "");
        
        StatementsCounter
        takeStatementsCounter(const QString &connection = "");
        
        DatabaseConnection &
        resetStatementsCounter(const QString &connection = "");

        

        bool anyCountingStatements();
        
        void enableAllStatementCounters();
        
        void disableAllStatementCounters();
        
        StatementsCounter getAllStatementCounters();
        
        StatementsCounter takeAllStatementCounters();
        
        void resetAllStatementCounters();

        
        void enableStatementCounters(const QStringList &connections);
        
        void disableStatementCounters(const QStringList &connections);
        
        StatementsCounter getStatementCounters(const QStringList &connections);
        
        StatementsCounter takeStatementCounters(const QStringList &connections);
        
        void resetStatementCounters(const QStringList &connections);

    private:
        

        explicit DatabaseManager(const QString &defaultConnection);
        

        explicit DatabaseManager(const QVariantHash &config, const QString &connection,
                                 const QString &defaultConnection);
        

        explicit DatabaseManager(const ConfigurationsType &configs,
                                 const QString &defaultConnection);

        
        DatabaseManager &setupDefaultReconnector();

        
        const QString &parseConnectionName(const QString &name) const;

        
        std::shared_ptr<DatabaseConnection>
        makeConnection(const QString &connection);

        
        QVariantHash &configuration(const QString &connection);
        
        void throwIfNoConfiguration(const QString &connection) const;

        
        std::shared_ptr<DatabaseConnection>
        configure(std::shared_ptr<DatabaseConnection> &&connection) const;

        

        DatabaseConnection &refreshQtConnection(const QString &connection);

        
        static void checkInstance();

        

        static void registerQMetaTypesForQt5();
#line 403 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"

        
        Configuration m_configuration {};
        
        Support::DatabaseConnectionsMap m_connections {};
        
        ReconnectorType m_reconnector = nullptr;

        
        static std::shared_ptr<DatabaseManager> m_instance;
    };

    

    

    Query::Expression
    DatabaseManager::raw(const QVariant &value) const 
    {
        return Query::Expression(value);
    }

    Query::Expression
    DatabaseManager::raw(QVariant &&value) const noexcept 
    {
        return Query::Expression(std::move(value));
    }

    

    DatabaseConnection &DatabaseManager::on(const QString &connection)
    {
        return this->connection(connection);
    }

} 



#line 443 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/databasemanager.hpp"
#line 2 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"




























#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"






















__pragma(warning(push))






















#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/prologue.hpp"

#pragma external_header(pop)
#line 30 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"




namespace ranges
{
    
    namespace detail
    {
        template<typename T>
        constexpr T & get_first_second_helper(T & t, std::true_type) noexcept
        {
            return t;
        }

         template<typename T > requires move_constructible<T>
#line 47 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"
        constexpr T get_first_second_helper(T & t, std::false_type) 
            noexcept(std::is_nothrow_move_constructible<T>::value)
        {
            return std::move(t);
        }

        template<typename P, typename E>
        using get_first_second_tag = meta::bool_<std::is_lvalue_reference<P>::value ||
                                                 std::is_lvalue_reference<E>::value>;

        struct get_first
        {
            
            template<typename Pair>
            constexpr auto operator() (Pair &&p) const noexcept(noexcept(get_first_second_helper( p.first, get_first_second_tag<Pair, decltype(p.first)>{}))) -> decltype(get_first_second_helper( p.first, get_first_second_tag<Pair, decltype(p.first)>{})) { return (get_first_second_helper( p.first, get_first_second_tag<Pair, decltype(p.first)>{})); }
#line 67 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"
            
        };

        struct get_second
        {
            
            template<typename Pair>
            constexpr auto operator() (Pair &&p) const noexcept(noexcept(get_first_second_helper( p.second, get_first_second_tag<Pair, decltype(p.second)>{}))) -> decltype(get_first_second_helper( p.second, get_first_second_tag<Pair, decltype(p.second)>{})) { return (get_first_second_helper( p.second, get_first_second_tag<Pair, decltype(p.second)>{})); }
#line 80 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"
            
        };

        
        
        
        template<typename T>
        concept kv_pair_like_ =
            invocable<get_first const &, T> &&
            invocable<get_second const &, T>;
        
    } 
    

    
    
    namespace views
    {
        struct keys_fn
        {
             template<typename Rng > requires viewable_range<Rng> && input_range<Rng> && detail::kv_pair_like_<range_reference_t<Rng>>
#line 103 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"
            keys_range_view<all_t<Rng>> operator()(Rng && rng) const
            {
                return {all(static_cast<Rng &&>(rng)), detail::get_first{}};
            }
        };

        struct values_fn
        {
             template<typename Rng > requires viewable_range<Rng> && input_range<Rng> && detail::kv_pair_like_<range_reference_t<Rng>>
#line 114 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"
            values_view<all_t<Rng>> operator()(Rng && rng) const
            {
                return {all(static_cast<Rng &&>(rng)), detail::get_second{}};
            }
        };

        
        
        inline constexpr view_closure<keys_fn> keys{};

        
        
        inline constexpr view_closure<values_fn> values{};
    } 

    template<typename Rng>
    inline constexpr bool enable_borrowed_range<keys_range_view<Rng>> =
        enable_borrowed_range<Rng>;
    template<typename Rng>
    inline constexpr bool enable_borrowed_range<values_view<Rng>> =
        enable_borrowed_range<Rng>;

    namespace cpp20
    {
        namespace views
        {
            using ranges::views::keys;
            using ranges::views::values;
        } 
        
    } 
    
} 

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/detail/epilogue.hpp"





















__pragma(warning(pop))
#pragma external_header(pop)
#line 149 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"

#line 151 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\range/v3/view/map.hpp"
#pragma external_header(pop)
#line 4 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/hasconnectionresolver.hpp"
#pragma once




__pragma(system_header)






namespace Orm
{
    class ConnectionResolverInterface;

namespace Concerns
{

    
    class __declspec(dllexport) HasConnectionResolver
    {
    public:
        
        static ConnectionResolverInterface *getConnectionResolver() noexcept;

        
        static void setConnectionResolver(ConnectionResolverInterface *resolver) noexcept;

        
        static void unsetConnectionResolver() noexcept;
    };

} 
} 



#line 40 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/concerns/hasconnectionresolver.hpp"
#line 6 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectors/connectionfactory.hpp"
#pragma once




__pragma(system_header)









namespace Orm
{
    class DatabaseConnection;

namespace Connectors
{

    
    class ConnectionFactory
    {
        ConnectionFactory(const ConnectionFactory &) = delete; ConnectionFactory &operator=(const ConnectionFactory &) = delete; ConnectionFactory(ConnectionFactory &&) = delete; ConnectionFactory &operator=(ConnectionFactory &&) = delete;

    public:
        
        ConnectionFactory() = delete;
        
        ~ConnectionFactory() = delete;

        
        static std::shared_ptr<DatabaseConnection>
        make(QVariantHash &config, const ConnectionName &connection);

        
        static std::unique_ptr<ConnectorInterface>
        createConnector(const QVariantHash &config);

    protected:
        
        static QVariantHash
        parseConfiguration(QVariantHash &config, const ConnectionName &connection);

        
        static std::shared_ptr<DatabaseConnection>
        createSingleConnection(QVariantHash &&config);
        

        static std::function<ConnectionName()>
        createQSqlDatabaseResolver(const QVariantHash &config);

        

        static std::function<ConnectionName()>
        createQSqlDatabaseResolverWithHosts(const QVariantHash &config);
        

        static std::function<ConnectionName()>
        createQSqlDatabaseResolverWithoutHosts(const QVariantHash &config);

        
        static std::shared_ptr<DatabaseConnection>
        createConnection(
                const QString &driver, std::function<ConnectionName()> &&connection,
                QString &&database, QString &&tablePrefix = "",
                QtTimeZoneConfig &&qtTimeZone = {QtTimeZoneType::QtTimeSpec, Qt::UTC},
                QVariantHash &&config = {},
                std::optional<bool> returnQDateTime = std::nullopt);

        
        static QStringList parseHosts(const QVariantHash &config);
        
        static void validateHosts(const QStringList &hosts);
    };

} 
} 



#line 85 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/connectors/connectionfactory.hpp"
#line 7 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/invalidargumenterror.hpp"
#pragma once




__pragma(system_header)

#line 1 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/logicerror.hpp"
#pragma once




__pragma(system_header)

#pragma external_header(push)
#line 1 "F:\\Frank\\src\\vcpkg\\installed\\x64-windows\\include\\qt5\\QtCore\\QString"

#pragma external_header(pop)
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/logicerror.hpp"








namespace Orm::Exceptions
{

    
    class __declspec(dllexport) LogicError : public std::logic_error, 
                                        public OrmError
    {
    public:
        
        explicit LogicError(const char *message);
        
        explicit LogicError(const QString &message);
        
        explicit LogicError(const std::string &message);

        
        inline const QString &message() const noexcept;

    protected:
        
        QString m_message = what();
    };

    

    const QString &LogicError::message() const noexcept
    {
        return m_message;
    }

} 



#line 52 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/logicerror.hpp"
#line 9 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/invalidargumenterror.hpp"



namespace Orm::Exceptions
{

    
    class InvalidArgumentError : public LogicError 
    {
        
        using LogicError::LogicError;
    };

} 



#line 27 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\include\\orm/exceptions/invalidargumenterror.hpp"
#line 8 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"



namespace Orm
{






DatabaseManager::~DatabaseManager() = default;



std::shared_ptr<DatabaseManager> DatabaseManager::m_instance;

DatabaseManager::DatabaseManager(const QString &defaultConnection)
{
    Configuration::defaultConnection = defaultConnection;

    
    Concerns::HasConnectionResolver::setConnectionResolver(this);

    setupDefaultReconnector();

    


    registerQMetaTypesForQt5();
#line 39 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
}

DatabaseManager::DatabaseManager(const QVariantHash &config, const QString &connection,
                                 const QString &defaultConnection)
    : DatabaseManager(defaultConnection)
{
    addConnection(config, connection);
}

DatabaseManager::DatabaseManager(const ConfigurationsType &configs,
                                 const QString &defaultConnection)
    : DatabaseManager(defaultConnection)
{
    *m_configuration = configs;
}

DatabaseManager &DatabaseManager::setupDefaultReconnector()
{
    m_reconnector = [this](const DatabaseConnection &connection)
    {
        reconnect(connection.getName());
    };

    return *this;
}





std::shared_ptr<DatabaseManager>
DatabaseManager::create(const QString &defaultConnection)
{
    checkInstance();

    
    return m_instance = std::shared_ptr<DatabaseManager>(
                            new DatabaseManager(defaultConnection));
}


std::shared_ptr<DatabaseManager>
DatabaseManager::create(const QVariantHash &config, const QString &connection)
{
    checkInstance();

    
    return m_instance = std::shared_ptr<DatabaseManager>(
                            new DatabaseManager(config, connection, connection));
}

std::shared_ptr<DatabaseManager>
DatabaseManager::create(const ConfigurationsType &configs,
                        const QString &defaultConnection)
{
    checkInstance();

    
    return m_instance = std::shared_ptr<DatabaseManager>(
                            new DatabaseManager(configs, defaultConnection));
}



std::shared_ptr<QueryBuilder>
DatabaseManager::table(const QString &table, const QString &connection)
{
    return this->connection(connection).table(table);
}

std::shared_ptr<QueryBuilder>
DatabaseManager::tableAs(const QString &table, const QString &as,
                         const QString &connection)
{
    return this->connection(connection).table(table, as);
}

std::shared_ptr<QueryBuilder>
DatabaseManager::query(const QString &connection)
{
    return this->connection(connection).query();
}

QSqlQuery DatabaseManager::qtQuery(const QString &connection)
{
    return this->connection(connection).getQtQuery();
}

SqlQuery
DatabaseManager::select(const QString &query, QVector<QVariant> bindings,
                        const QString &connection)
{
    return this->connection(connection).select(query, std::move(bindings));
}

SqlQuery
DatabaseManager::selectFromWriteConnection(
        const QString &query, QVector<QVariant> bindings,
        const QString &connection)
{
    return this->connection(connection)
                .selectFromWriteConnection(query, std::move(bindings));
}

SqlQuery
DatabaseManager::selectOne(const QString &query, QVector<QVariant> bindings,
                           const QString &connection)
{
    return this->connection(connection).selectOne(query, std::move(bindings));
}

QVariant
DatabaseManager::scalar(const QString &query, QVector<QVariant> bindings,
                        const QString &connection)
{
    return this->connection(connection).scalar(query, std::move(bindings));
}

SqlQuery
DatabaseManager::insert(const QString &query, QVector<QVariant> bindings,
                        const QString &connection)
{
    return this->connection(connection).insert(query, std::move(bindings));
}

std::tuple<int, QSqlQuery>
DatabaseManager::update(const QString &query, QVector<QVariant> bindings,
                        const QString &connection)
{
    return this->connection(connection).update(query, std::move(bindings));
}

std::tuple<int, QSqlQuery>
DatabaseManager::remove(const QString &query, QVector<QVariant> bindings,
                        const QString &connection)
{
    return this->connection(connection).remove(query, std::move(bindings));
}

SqlQuery
DatabaseManager::statement(const QString &query, QVector<QVariant> bindings,
                           const QString &connection)
{
    return this->connection(connection).statement(query, std::move(bindings));
}

std::tuple<int, QSqlQuery>
DatabaseManager::affectingStatement(const QString &query, QVector<QVariant> bindings,
                                    const QString &connection)
{
    return this->connection(connection).affectingStatement(query, std::move(bindings));
}

SqlQuery DatabaseManager::unprepared(const QString &query,
                                     const QString &connection)
{
    return this->connection(connection).unprepared(query);
}

bool DatabaseManager::beginTransaction(const QString &connection)
{
    return this->connection(connection).beginTransaction();
}

bool DatabaseManager::commit(const QString &connection)
{
    return this->connection(connection).commit();
}

bool DatabaseManager::rollBack(const QString &connection)
{
    return this->connection(connection).rollBack();
}

bool DatabaseManager::savepoint(const QString &id, const QString &connection)
{
    return this->connection(connection).savepoint(id);
}

bool DatabaseManager::savepoint(const std::size_t id, const QString &connection)
{
    return this->connection(connection).savepoint(id);
}

bool DatabaseManager::rollbackToSavepoint(const QString &id, const QString &connection)
{
    return this->connection(connection).rollbackToSavepoint(id);
}

bool DatabaseManager::rollbackToSavepoint(const std::size_t id,
                                          const QString &connection)
{
    return this->connection(connection).rollbackToSavepoint(id);
}

size_t DatabaseManager::transactionLevel(const QString &connection)
{
    return this->connection(connection).transactionLevel();
}

bool DatabaseManager::isOpen(const QString &connection)
{
    return this->connection(connection).isOpen();
}

bool DatabaseManager::pingDatabase(const QString &connection)
{
    return this->connection(connection).pingDatabase();
}

QSqlDriver *DatabaseManager::driver(const QString &connection)
{
    return this->connection(connection).driver();
}



namespace
{
    const auto *const InstanceExceptionMessage =
            "The DatabaseManager instance has not yet been created, create it "
            "by the DB::create() method.";
} 

std::shared_ptr<DatabaseManager> DatabaseManager::instance()
{
    if (m_instance)
        return m_instance;

    throw Exceptions::RuntimeError(InstanceExceptionMessage);
}

DatabaseManager &DatabaseManager::reference()
{
    if (m_instance)
        return *m_instance;

    throw Exceptions::RuntimeError(InstanceExceptionMessage);
}

DatabaseConnection &DatabaseManager::connection(const QString &name)
{
    const auto &connectionName = parseConnectionName(name);

    

    if (!m_connections->contains(connectionName))
        m_connections->emplace(connectionName,
                               configure(makeConnection(connectionName)));

    return *(*m_connections)[connectionName];
}

DatabaseManager &
DatabaseManager::addConnection(const QVariantHash &config, const QString &name)
{
    if (m_configuration->contains(name))
        throw Exceptions::InvalidArgumentError(
                ([]() noexcept -> QString { enum { Size = sizeof(u"" "The database connection '%1' already exists.")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "The database connection '%1' already exists." }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }())
                .arg(name));

    m_configuration->emplace(name, config);

    return *this;
}

DatabaseManager &
DatabaseManager::addConnections(const ConfigurationsType &configs)
{
    for (const auto &[name, config] : configs)
        addConnection(config, name);

    return *this;
}

DatabaseManager &
DatabaseManager::addConnections(const ConfigurationsType &configs,
                                const QString &defaultConnection)
{
    addConnections(configs);

    Configuration::defaultConnection = defaultConnection;

    return *this;
}

bool DatabaseManager::removeConnection(const QString &name)
{
    const auto &name_ = parseConnectionName(name);

    
    if (!connectionNames().contains(name_))
        return false;

    

    const auto resetDefaultConnection_ = [this, &name]
    {
        if (Configuration::defaultConnection == name)
            resetDefaultConnection();
    };

    
    if (!m_connections->contains(name_)) {
        m_configuration->erase(name_);
        resetDefaultConnection_();
        return true;
    }

    
    m_connections->find(name_)->second->disconnect();

    

    if (m_connections->erase(name_) == 0)
        return false;

    
    m_configuration->erase(name_);
    
    QSqlDatabase::removeDatabase(name_);

    resetDefaultConnection_();

    return true;
}

bool DatabaseManager::containsConnection(const QString &name)
{
    return m_connections->contains(name);
}

DatabaseConnection &DatabaseManager::reconnect(const QString &name)
{
    const auto &name_ = parseConnectionName(name);

    disconnect(name_);

    if (!m_connections->contains(name_))
        return connection(name_);

    return refreshQtConnection(name_);
}

void DatabaseManager::disconnect(const QString &name) const
{
    const auto &name_ = parseConnectionName(name);

    if (!m_connections->contains(name_))
        return;

    m_connections->find(name_)->second->disconnect();
}

void DatabaseManager::connectEagerly(const QString &name)
{
    connection(name).connectEagerly();
}

QStringList DatabaseManager::connectionNames() const
{
    return *m_configuration | ranges::views::keys | ranges::to<QStringList>();
}

QStringList DatabaseManager::openedConnectionNames() const
{
    QStringList names;
    
    names.reserve(static_cast<decltype (names)::size_type>(m_connections->size()));

    for (const auto &connection : *m_connections)
        names << connection.first;

    return names;
}

std::size_t DatabaseManager::openedConnectionsSize() const noexcept
{
    return m_connections->size();
}

QStringList DatabaseManager::supportedDrivers() const 
{
    
    return {QMYSQL, QPSQL, QSQLITE};
}

QStringList DatabaseManager::drivers() const 
{
    return QSqlDatabase::drivers();
}

bool DatabaseManager::isDriverAvailable(const QString &driverName) const 
{
    return QSqlDatabase::isDriverAvailable(driverName);
}

bool DatabaseManager::isConnectionDriverAvailable(const QString &connection)
{
    const auto driverName = configuration(connection)[driver_].value<QString>();

    if (!supportedDrivers().contains(driverName))
        throw Exceptions::LogicError(
                ([]() noexcept -> QString { enum { Size = sizeof(u"" "An unsupported driver name '%1' has been defined for " "the '%2' connection.")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "An unsupported driver name '%1' has been defined for " "the '%2' connection." }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }())
#line 444 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
                .arg(driverName, connection));

    return QSqlDatabase::isDriverAvailable(driverName);
}

const QString &
DatabaseManager::getDefaultConnection() const noexcept
{
    return Configuration::defaultConnection;
}

void DatabaseManager::setDefaultConnection(const QString &defaultConnection)
{
    Configuration::defaultConnection = defaultConnection;
}

void DatabaseManager::resetDefaultConnection()
{
    Configuration::defaultConnection = Configuration::defaultConnectionName;
}

DatabaseManager &
DatabaseManager::setReconnector(const ReconnectorType &reconnector)
{
    m_reconnector = reconnector;

    return *this;
}



QString DatabaseManager::driverName(const QString &connection)
{
    return this->connection(connection).driverName();
}

const QString &
DatabaseManager::driverNamePrintable(const QString &connection)
{
    return this->connection(connection).driverNamePrintable();
}

const QString &
DatabaseManager::databaseName(const QString &connection)
{
    return this->connection(connection).getDatabaseName();
}

const QString &
DatabaseManager::hostName(const QString &connection)
{
    return this->connection(connection).getHostName();
}

const QtTimeZoneConfig &
DatabaseManager::qtTimeZone(const QString &connection)
{
    return this->connection(connection).getQtTimeZone();
}

DatabaseConnection &
DatabaseManager::setQtTimeZone(const QVariant &timezone, const QString &connection)
{
    return this->connection(connection).setQtTimeZone(timezone);
}

DatabaseConnection &
DatabaseManager::setQtTimeZone(QtTimeZoneConfig &&timezone, const QString &connection)
{
    return this->connection(connection).setQtTimeZone(std::move(timezone));
}

bool DatabaseManager::isConvertingTimeZone(const QString &connection)
{
    return this->connection(connection).isConvertingTimeZone();
}



QVariant
DatabaseManager::originalConfigValue(const QString &option,
                                     const QString &connection) const
{
    return originalConfig(connection).value(option);
}

const QVariantHash &
DatabaseManager::originalConfig(const QString &connection) const
{
    const auto &connectionName = parseConnectionName(connection);

    throwIfNoConfiguration(connectionName);

    return m_configuration->at(connectionName);
}

size_t DatabaseManager::originalConfigsSize() const
{
    return m_configuration->size();
}



QVariant DatabaseManager::getConfigValue(const QString &option, const QString &connection)
{
    return this->connection(connection).getConfig(option);
}

const QVariantHash &DatabaseManager::getConfig(const QString &connection)
{
    return this->connection(connection).getConfig();
}

bool DatabaseManager::hasConfigValue(const QString &option, const QString &connection)
{
    return this->connection(connection).hasConfig(option);
}



QVector<Log>
DatabaseManager::pretend(const std::function<void()> &callback,
                         const QString &connection)
{
    return this->connection(connection).pretend(callback);
}

QVector<Log>
DatabaseManager::pretend(const std::function<void(DatabaseConnection &)> &callback,
                         const QString &connection)
{
    return this->connection(connection).pretend(callback);
}



bool DatabaseManager::getRecordsHaveBeenModified(const QString &connection)
{
    return this->connection(connection).getRecordsHaveBeenModified();
}

void DatabaseManager::recordsHaveBeenModified(const bool value,
                                              const QString &connection)
{
    this->connection(connection).recordsHaveBeenModified(value);
}

void DatabaseManager::forgetRecordModificationState(const QString &connection)
{
    this->connection(connection).forgetRecordModificationState();
}



std::shared_ptr<QVector<Log>>
DatabaseManager::getQueryLog(const QString &connection)
{
    return this->connection(connection).getQueryLog();
}

void DatabaseManager::flushQueryLog(const QString &connection)
{
    this->connection(connection).flushQueryLog();
}

void DatabaseManager::enableQueryLog(const QString &connection)
{
    this->connection(connection).enableQueryLog();
}

void DatabaseManager::disableQueryLog(const QString &connection)
{
    this->connection(connection).disableQueryLog();
}

bool DatabaseManager::logging(const QString &connection)
{
    return this->connection(connection).logging();
}

std::size_t DatabaseManager::getQueryLogOrder() const noexcept 
{
    return DatabaseConnection::getQueryLogOrder();
}



bool DatabaseManager::countingElapsed(const QString &connection)
{
    return this->connection(connection).countingElapsed();
}

DatabaseConnection &DatabaseManager::enableElapsedCounter(const QString &connection)
{
    return this->connection(connection).enableElapsedCounter();
}

DatabaseConnection &DatabaseManager::disableElapsedCounter(const QString &connection)
{
    return this->connection(connection).disableElapsedCounter();
}

qint64 DatabaseManager::getElapsedCounter(const QString &connection)
{
    return this->connection(connection).getElapsedCounter();
}

qint64 DatabaseManager::takeElapsedCounter(const QString &connection)
{
    return this->connection(connection).takeElapsedCounter();
}

DatabaseConnection &DatabaseManager::resetElapsedCounter(const QString &connection)
{
    return this->connection(connection).resetElapsedCounter();
}

bool DatabaseManager::anyCountingElapsed()
{
    return std::ranges::any_of(openedConnectionNames(),
                               [this](const auto &connectionName)
    {
        return connection(connectionName).countingElapsed();
    });
}

void DatabaseManager::enableAllElapsedCounters()
{
    enableElapsedCounters(openedConnectionNames());
}

void DatabaseManager::disableAllElapsedCounters()
{
    disableElapsedCounters(openedConnectionNames());
}

qint64 DatabaseManager::getAllElapsedCounters()
{
    return getElapsedCounters(openedConnectionNames());
}

qint64 DatabaseManager::takeAllElapsedCounters()
{
    return takeElapsedCounters(openedConnectionNames());
}

void DatabaseManager::resetAllElapsedCounters()
{
    resetElapsedCounters(openedConnectionNames());
}

void DatabaseManager::enableElapsedCounters(const QStringList &connections)
{
    for (const auto &connectionName : connections)
        connection(connectionName).enableElapsedCounter();
}

void DatabaseManager::disableElapsedCounters(const QStringList &connections)
{
    for (const auto &connectionName : connections)
        connection(connectionName).disableElapsedCounter();
}

qint64 DatabaseManager::getElapsedCounters(const QStringList &connections)
{
    if (!anyCountingElapsed())
        return -1;

    qint64 elapsed = 0;

    for (const auto &connectionName : connections) {
        const auto &connection = this->connection(connectionName);

        if (connection.countingElapsed())
            elapsed += connection.getElapsedCounter();
    }

    return elapsed;
}

qint64 DatabaseManager::takeElapsedCounters(const QStringList &connections)
{
    if (!anyCountingElapsed())
        return -1;

    qint64 elapsed = 0;

    for (const auto &connectionName : connections) {
        auto &connection = this->connection(connectionName);

        if (connection.countingElapsed())
            elapsed += connection.takeElapsedCounter();
    }

    return elapsed;
}

void DatabaseManager::resetElapsedCounters(const QStringList &connections)
{
    for (const auto &connectionName : connections) {
        auto &connection = this->connection(connectionName);

        if (connection.countingElapsed())
            connection.resetElapsedCounter();
    }
}



bool DatabaseManager::countingStatements(const QString &connection)
{
    return this->connection(connection).countingStatements();
}

DatabaseConnection &DatabaseManager::enableStatementsCounter(const QString &connection)
{
    return this->connection(connection).enableStatementsCounter();
}

DatabaseConnection &DatabaseManager::disableStatementsCounter(const QString &connection)
{
    return this->connection(connection).disableStatementsCounter();
}

const StatementsCounter &DatabaseManager::getStatementsCounter(const QString &connection)
{
    return this->connection(connection).getStatementsCounter();
}

StatementsCounter DatabaseManager::takeStatementsCounter(const QString &connection)
{
    return this->connection(connection).takeStatementsCounter();
}

DatabaseConnection &DatabaseManager::resetStatementsCounter(const QString &connection)
{
    return this->connection(connection).resetStatementsCounter();
}

bool DatabaseManager::anyCountingStatements()
{
    return std::ranges::any_of(openedConnectionNames(),
                               [this](const auto &connectionName)
    {
        return connection(connectionName).countingStatements();
    });
}

void DatabaseManager::enableAllStatementCounters()
{
    enableStatementCounters(openedConnectionNames());
}

void DatabaseManager::disableAllStatementCounters()
{
    disableStatementCounters(openedConnectionNames());
}

StatementsCounter DatabaseManager::getAllStatementCounters()
{
    return getStatementCounters(openedConnectionNames());
}

StatementsCounter DatabaseManager::takeAllStatementCounters()
{
    return takeStatementCounters(openedConnectionNames());
}

void DatabaseManager::resetAllStatementCounters()
{
    resetStatementCounters(openedConnectionNames());
}

void DatabaseManager::enableStatementCounters(const QStringList &connections)
{
    for (const auto &connectionName : connections)
        connection(connectionName).enableStatementsCounter();
}

void DatabaseManager::disableStatementCounters(const QStringList &connections)
{
    for (const auto &connectionName : connections)
        connection(connectionName).disableStatementsCounter();
}

StatementsCounter DatabaseManager::getStatementCounters(const QStringList &connections)
{
    StatementsCounter counter;

    if (!anyCountingStatements())
        return counter;

    for (const auto &connectionName : connections) {
        const auto &connection = this->connection(connectionName);

        if (connection.countingStatements()) {
            const auto &counter_ = connection.getStatementsCounter();

            counter.normal        += counter_.normal;
            counter.affecting     += counter_.affecting;
            counter.transactional += counter_.transactional;
        }
    }

    return counter;
}

StatementsCounter DatabaseManager::takeStatementCounters(const QStringList &connections)
{
    StatementsCounter counter;

    if (!anyCountingStatements())
        return counter;

    for (const auto &connectionName : connections) {
        auto &connection = this->connection(connectionName);

        if (connection.countingElapsed()) {
            const auto counter_ = connection.takeStatementsCounter();

            counter.normal        += counter_.normal;
            counter.affecting     += counter_.affecting;
            counter.transactional += counter_.transactional;
        }
    }

    return counter;
}

void DatabaseManager::resetStatementCounters(const QStringList &connections)
{
    for (const auto &connectionName : connections) {
        auto &connection = this->connection(connectionName);

        if (connection.countingElapsed())
            connection.resetStatementsCounter();
    }
}



const QString &
DatabaseManager::parseConnectionName(const QString &name) const
{
    return name.isEmpty() ? getDefaultConnection() : name;
}

std::shared_ptr<DatabaseConnection>
DatabaseManager::makeConnection(const QString &connection)
{
    auto &config = configuration(connection);

    

    return Connectors::ConnectionFactory::make(config, connection);
}



QVariantHash &
DatabaseManager::configuration(const QString &connection)
{
    const auto &connectionName = parseConnectionName(connection);

    throwIfNoConfiguration(connectionName);

    return (*m_configuration)[connectionName]; 

    


}

void DatabaseManager::throwIfNoConfiguration(const QString &connection) const
{
    

    if (m_configuration->contains(connection))
        return;

    throw Exceptions::InvalidArgumentError(
                ([]() noexcept -> QString { enum { Size = sizeof(u"" "Database connection '%1' is not configured.")/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "Database connection '%1' is not configured." }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }())
                .arg(connection));
}

std::shared_ptr<DatabaseConnection>
DatabaseManager::configure(std::shared_ptr<DatabaseConnection> &&connection) const
{
    


    connection->setReconnector(m_reconnector);

    return std::move(connection);
}

DatabaseConnection &
DatabaseManager::refreshQtConnection(const QString &connection)
{
    const auto &connectionName = parseConnectionName(connection);

    


    auto fresh = configure(makeConnection(connectionName));

    return (*m_connections)[connectionName]->setQtConnectionResolver(
                fresh->getQtConnectionResolver());
}

void DatabaseManager::checkInstance()
{
    if (!m_instance)
        return;

    throw Exceptions::RuntimeError(
            "Only one instance of DatabaseManager is allowed per process.");
}


void DatabaseManager::registerQMetaTypesForQt5()
{
    if (!QMetaType::hasRegisteredComparators<QtTimeZoneConfig>())
        QMetaType::registerEqualsComparator<QtTimeZoneConfig>();

    
    if (!QMetaType::hasRegisteredComparators<QVector<QVariantMap>>())
        QMetaType::registerEqualsComparator<QVector<QVariantMap>>();


    using AttributeItem = Tiny::AttributeItem;

    if (!QMetaType::hasRegisteredComparators<AttributeItem>())
        QMetaType::registerEqualsComparator<AttributeItem>();

    if (!QMetaType::hasRegisteredComparators<QVector<AttributeItem>>())
        QMetaType::registerEqualsComparator<QVector<AttributeItem>>();

    if (!QMetaType::hasRegisteredComparators<QVector<QVector<AttributeItem>>>())
        QMetaType::registerEqualsComparator<QVector<QVector<AttributeItem>>>();
#line 985 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"
}
#line 987 "F:\\Frank\\src\\vcpkg\\buildtrees\\tinyorm\\src\\v0.36.5-06b8c90c92.clean\\src\\orm\\databasemanager.cpp"

}