// Target: riscv64-linux-gnu // Configured with: ../src/configure -v --with-pkgversion='Ubuntu 15.2.0-4ubuntu4' --with-bugurl=file:///usr/share/doc/gcc-15/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2,rust,cobol,algol68 --prefix=/usr --with-gcc-major-version-only --program-suffix=-15 --program-prefix=riscv64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-libquadmath --disable-libquadmath-support --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --disable-multilib --with-abi=lp64d --with-arch=rv64i_m_a_f_d_c_b_v_zic64b_zicbom_zicbop_zicboz_ziccamoa_ziccif_zicclsm_ziccrse_zicntr_zicond_zicsr_zifencei_zihintntl_zihintpause_zihpm_zimop_zmmul_za64rs_zaamo_zalrsc_zawrs_zfa_zfhmin_zca_zcb_zcd_zcmop_zba_zbb_zbs_zkt_zvbb_zve32f_zve32x_zve64d_zve64f_zve64x_zvfhmin_zvkb_zvkt_zvl128b_zvl32b_zvl64b_supm --enable-checking=release --build=riscv64-linux-gnu --host=riscv64-linux-gnu --target=riscv64-linux-gnu // Thread model: posix // Supported LTO compression algorithms: zlib zstd // gcc version 15.2.0 (Ubuntu 15.2.0-4ubuntu4) // // during GIMPLE pass: lower // In file included from /build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp:1: // /build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp: In function ‘void at::native::{anonymous}::winograd_f2k3_kernel_transform__rvv(vfloat32m1_t, vfloat32m1_t, vfloat32m1_t, vfloat32m1x4_t*)’: // /build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp:307:44: internal compiler error: in gsi_replace, at gimple-iterator.cc:438 // 307 | *transform = __riscv_vset_v_f32m1_f32m1x4(*transform, 3, g2); // | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~ // 0x238f2c9 diagnostic_context::diagnostic_impl(rich_location*, diagnostic_metadata const*, diagnostic_option_id, char const*, void**, diagnostic_t) // ???:0 // 0x239bfcb internal_error(char const*, ...) // ???:0 // 0x6781cd fancy_abort(char const*, int, char const*) // ???:0 // 0xa47005 gsi_replace(gimple_stmt_iterator*, gimple*, bool) // ???:0 // 0x1046305 riscv_gimple_fold_builtin(gimple_stmt_iterator*) // ???:0 // Please submit a full bug report, with preprocessed source (by using -freport-bug). // Please include the complete backtrace with any bug report. // See for instructions. // /usr/libexec/gcc/riscv64-linux-gnu/15/cc1plus -quiet -I /build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src -I /build/reproducible-path/pytorch-2.6.0+dfsg/aten/src -I /build/reproducible-path/pytorch-2.6.0+dfsg/build -I /build/reproducible-path/pytorch-2.6.0+dfsg -I /build/reproducible-path/pytorch-2.6.0+dfsg/cmake/../third_party/benchmark/include -I /usr/lib/llvm-19/include -I /build/reproducible-path/pytorch-2.6.0+dfsg/nlohmann -I /build/reproducible-path/pytorch-2.6.0+dfsg/torch/csrc/api -I /build/reproducible-path/pytorch-2.6.0+dfsg/torch/csrc/api/include -I /build/reproducible-path/pytorch-2.6.0+dfsg/caffe2/aten/src/TH -I /build/reproducible-path/pytorch-2.6.0+dfsg/build/caffe2/aten/src/TH -I /build/reproducible-path/pytorch-2.6.0+dfsg/build/caffe2/aten/src -I /build/reproducible-path/pytorch-2.6.0+dfsg/build/caffe2/../aten/src -I /build/reproducible-path/pytorch-2.6.0+dfsg/torch/csrc -I /build/reproducible-path/pytorch-2.6.0+dfsg/third_party/miniz-3.0.2 -I /build/reproducible-path/pytorch-2.6.0+dfsg/debian/kineto/libkineto/include -I /build/reproducible-path/pytorch-2.6.0+dfsg/debian/kineto/libkineto/src -I /build/reproducible-path/pytorch-2.6.0+dfsg/third_party/cpp-httplib -I /build/reproducible-path/pytorch-2.6.0+dfsg/build/vulkan -I /build/reproducible-path/pytorch-2.6.0+dfsg/aten/../third_party/VulkanMemoryAllocator -I /build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/.. -I /build/reproducible-path/pytorch-2.6.0+dfsg/c10/.. -I /build/reproducible-path/pytorch-2.6.0+dfsg/third_party/flatbuffers/include -I /usr -imultilib . -imultiarch riscv64-linux-gnu -MD caffe2/CMakeFiles/torch_cpu.dir/__/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp.d -MF caffe2/CMakeFiles/torch_cpu.dir/__/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp.o.d -MT caffe2/CMakeFiles/torch_cpu.dir/__/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp.o -D_GNU_SOURCE -D_REENTRANT -D AT_PER_OPERATOR_HEADERS -D CAFFE2_BUILD_MAIN_LIB -D FLASHATTENTION_DISABLE_ALIBI -D FMT_HEADER_ONLY=1 -D HAVE_MALLOC_USABLE_SIZE=1 -D HAVE_MMAP=1 -D HAVE_SHM_OPEN=1 -D HAVE_SHM_UNLINK=1 -D MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS -D ONNXIFI_ENABLE_EXT=1 -D ONNX_ML=1 -D ONNX_NAMESPACE=onnx -D TORCH_ENABLE_LLVM -D USE_C10D_GLOO -D USE_C10D_MPI -D USE_DISTRIBUTED -D USE_EXTERNAL_MZCRC -D USE_RPC -D USE_TENSORPIPE -D _FILE_OFFSET_BITS=64 -D torch_cpu_EXPORTS -D _FORTIFY_SOURCE=3 -D _GLIBCXX_USE_CXX11_ABI=1 -D USE_KINETO -D LIBKINETO_NOCUPTI -D LIBKINETO_NOROCTRACER -D LIBKINETO_NOXPUPTI=ON -D USE_VULKAN -D USE_VULKAN_API -D SYMBOLICATE_MOBILE_DEBUG_HANDLE -D NDEBUG -D TORCH_USE_LIBUV -D CAFFE2_USE_GLOO -D CPU_CAPABILITY=DEFAULT -D CPU_CAPABILITY_DEFAULT -isystem /build/reproducible-path/pytorch-2.6.0+dfsg/cmake/../third_party/googletest/googlemock/include -isystem /build/reproducible-path/pytorch-2.6.0+dfsg/cmake/../third_party/googletest/googletest/include -isystem /usr/include/eigen3 -isystem /build/reproducible-path/pytorch-2.6.0+dfsg/INTERFACE -isystem /build/reproducible-path/pytorch-2.6.0+dfsg/third_party/nlohmann/include -isystem /build/reproducible-path/pytorch-2.6.0+dfsg/caffe2 -isystem /usr/lib/riscv64-linux-gnu/openmpi/include -isystem /usr/lib/riscv64-linux-gnu/openmpi/include/openmpi /build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp -quiet -dumpdir caffe2/CMakeFiles/torch_cpu.dir/__/aten/src/ATen/native/cpu/ -dumpbase DepthwiseConvKernel.cpp.DEFAULT.cpp.cpp -dumpbase-ext .cpp -march=rv64imafdcbv_zic64b_zicbom_zicbop_zicboz_ziccamoa_ziccif_zicclsm_ziccrse_zicntr_zicond_zicsr_zifencei_zihintntl_zihintpause_zihpm_zimop_zmmul_za64rs_zaamo_zalrsc_zawrs_zfa_zfhmin_zca_zcb_zcd_zcmop_zba_zbb_zbs_zkt_zvbb_zve32f_zve32x_zve64d_zve64f_zve64x_zvfhmin_zvkb_zvkt_zvl128b_zvl32b_zvl64b_supm -mabi=lp64d -misa-spec=20191213 -mtls-dialect=trad -march=rv64imafdcbv_zic64b_zicbom_zicbop_zicboz_ziccamoa_ziccif_zicclsm_ziccrse_zicntr_zicond_zicsr_zifencei_zihintntl_zihintpause_zihpm_zimop_zmmul_za64rs_zaamo_zalrsc_zawrs_zfa_zfhmin_zca_zcb_zcd_zcmop_zba_zbb_zbs_zkt_zvbb_zve32f_zve32x_zve64d_zve64f_zve64x_zvfhmin_zvkb_zvkt_zvl128b_zvl32b_zvl64b_supm -g -gsplit-dwarf -g -O2 -O2 -O2 -O2 -O3 -Wdate-time -Wformat=1 -Werror=format-security -Wno-dangling-reference -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-type-limits -Warray-bounds=0 -Wstringop-overflow=0 -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -Wno-missing-braces -Werror=format -Wno-error=dangling-reference -Wno-error=redundant-move -Wstringop-overflow=0 -Wall -Wextra -Wdeprecated -Wno-unused-parameter -Wno-missing-field-initializers -Warray-bounds=0 -Wno-unknown-pragmas -Wno-strict-overflow -Wno-strict-aliasing -Wunused-function -Wunused-variable -Wunused-but-set-variable -Wno-maybe-uninitialized -std=gnu++17 -fdiagnostics-color=always -fno-omit-frame-pointer -ffile-prefix-map=/build/reproducible-path/pytorch-2.6.0+dfsg=. -fstack-protector-strong -fno-stack-clash-protection -fdebug-prefix-map=/build/reproducible-path/pytorch-2.6.0+dfsg=/usr/src/pytorch-2.6.0+dfsg-9 -fvisibility-inlines-hidden -faligned-new=1 -fno-math-errno -fno-trapping-math -fPIC -fvisibility=hidden -fopenmp -fstack-protector-strong -Wformat-security -fzero-init-padding-bits=all -Wbidi-chars=any -o - -frandom-seed=0 -fdump-noaddr # 0 "/build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp" # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/build//" # 0 "" # 0 "" # 1 "/usr/include/stdc-predef.h" 1 3 4 # 0 "" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp.DEFAULT.cpp" # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Export.h" 1 # 44 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Export.h" # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/build/c10/macros/cmake_macros.h" 1 # 45 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Export.h" 2 # 9 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" 2 # 1 "/usr/include/c++/15/cstddef" 1 3 # 51 "/usr/include/c++/15/cstddef" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 1 3 # 37 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wvariadic-macros" #pragma GCC diagnostic ignored "-Wc++11-extensions" #pragma GCC diagnostic ignored "-Wc++23-extensions" # 336 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 namespace std { typedef long unsigned int size_t; typedef long int ptrdiff_t; typedef decltype(nullptr) nullptr_t; #pragma GCC visibility push(default) extern "C++" __attribute__ ((__noreturn__, __always_inline__)) inline void __terminate() noexcept { void terminate() noexcept __attribute__ ((__noreturn__,__cold__)); terminate(); } #pragma GCC visibility pop } # 369 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 namespace std { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } } namespace __gnu_cxx { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } } # 573 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 namespace std { #pragma GCC visibility push(default) __attribute__((__always_inline__)) constexpr inline bool __is_constant_evaluated() noexcept { return __builtin_is_constant_evaluated(); } #pragma GCC visibility pop } # 617 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 namespace std { #pragma GCC visibility push(default) extern "C++" __attribute__ ((__noreturn__)) __attribute__((__cold__)) void __glibcxx_assert_fail (const char* __file, int __line, const char* __function, const char* __condition) noexcept; #pragma GCC visibility pop } # 648 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 namespace std { __attribute__((__always_inline__,__visibility__("default"))) inline void __glibcxx_assert_fail() { } } # 727 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/os_defines.h" 1 3 # 39 "/usr/include/riscv64-linux-gnu/c++/15/bits/os_defines.h" 3 # 1 "/usr/include/features.h" 1 3 4 # 415 "/usr/include/features.h" 3 4 # 1 "/usr/include/features-time64.h" 1 3 4 # 20 "/usr/include/features-time64.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 21 "/usr/include/features-time64.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/timesize.h" 1 3 4 # 22 "/usr/include/features-time64.h" 2 3 4 # 416 "/usr/include/features.h" 2 3 4 # 523 "/usr/include/features.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 1 3 4 # 730 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 731 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/long-double.h" 1 3 4 # 732 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 2 3 4 # 524 "/usr/include/features.h" 2 3 4 # 547 "/usr/include/features.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/gnu/stubs.h" 1 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 6 "/usr/include/riscv64-linux-gnu/gnu/stubs.h" 2 3 4 # 17 "/usr/include/riscv64-linux-gnu/gnu/stubs.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/gnu/stubs-lp64d.h" 1 3 4 # 18 "/usr/include/riscv64-linux-gnu/gnu/stubs.h" 2 3 4 # 548 "/usr/include/features.h" 2 3 4 # 40 "/usr/include/riscv64-linux-gnu/c++/15/bits/os_defines.h" 2 3 # 728 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 2 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/cpu_defines.h" 1 3 # 731 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 2 3 # 887 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 namespace __gnu_cxx { typedef __decltype(0.0bf16) __bfloat16_t; } # 949 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 3 # 1 "/usr/include/c++/15/pstl/pstl_config.h" 1 3 # 950 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++config.h" 2 3 #pragma GCC diagnostic pop # 52 "/usr/include/c++/15/cstddef" 2 3 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 160 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 3 4 typedef long int ptrdiff_t; # 229 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 3 4 typedef long unsigned int size_t; # 440 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 3 4 typedef struct { long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); # 451 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 3 4 } max_align_t; typedef decltype(nullptr) nullptr_t; # 53 "/usr/include/c++/15/cstddef" 2 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 56 "/usr/include/c++/15/cstddef" 2 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" extern "C++" { namespace std { using ::max_align_t; } namespace std { enum class byte : unsigned char {}; template struct __byte_operand { }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand<__int128> { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; # 114 "/usr/include/c++/15/cstddef" 3 template struct __byte_operand : __byte_operand<_IntegerType> { }; template struct __byte_operand : __byte_operand<_IntegerType> { }; template struct __byte_operand : __byte_operand<_IntegerType> { }; template using __byte_op_t = typename __byte_operand<_IntegerType>::__type; template [[__gnu__::__always_inline__]] constexpr __byte_op_t<_IntegerType> operator<<(byte __b, _IntegerType __shift) noexcept { return (byte)(unsigned char)((unsigned)__b << __shift); } template [[__gnu__::__always_inline__]] constexpr __byte_op_t<_IntegerType> operator>>(byte __b, _IntegerType __shift) noexcept { return (byte)(unsigned char)((unsigned)__b >> __shift); } [[__gnu__::__always_inline__]] constexpr byte operator|(byte __l, byte __r) noexcept { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } [[__gnu__::__always_inline__]] constexpr byte operator&(byte __l, byte __r) noexcept { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } [[__gnu__::__always_inline__]] constexpr byte operator^(byte __l, byte __r) noexcept { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } [[__gnu__::__always_inline__]] constexpr byte operator~(byte __b) noexcept { return (byte)(unsigned char)~(unsigned)__b; } template [[__gnu__::__always_inline__]] constexpr __byte_op_t<_IntegerType>& operator<<=(byte& __b, _IntegerType __shift) noexcept { return __b = __b << __shift; } template [[__gnu__::__always_inline__]] constexpr __byte_op_t<_IntegerType>& operator>>=(byte& __b, _IntegerType __shift) noexcept { return __b = __b >> __shift; } [[__gnu__::__always_inline__]] constexpr byte& operator|=(byte& __l, byte __r) noexcept { return __l = __l | __r; } [[__gnu__::__always_inline__]] constexpr byte& operator&=(byte& __l, byte __r) noexcept { return __l = __l & __r; } [[__gnu__::__always_inline__]] constexpr byte& operator^=(byte& __l, byte __r) noexcept { return __l = __l ^ __r; } template [[nodiscard,__gnu__::__always_inline__]] constexpr _IntegerType to_integer(__byte_op_t<_IntegerType> __b) noexcept { return _IntegerType(__b); } } } #pragma GCC diagnostic pop # 11 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" 2 # 1 "/usr/include/c++/15/cstdint" 1 3 # 47 "/usr/include/c++/15/cstdint" 3 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stdint.h" 1 3 4 # 9 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stdint.h" 3 4 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" # 1 "/usr/include/stdint.h" 1 3 4 # 26 "/usr/include/stdint.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/types.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 28 "/usr/include/riscv64-linux-gnu/bits/types.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/timesize.h" 1 3 4 # 29 "/usr/include/riscv64-linux-gnu/bits/types.h" 2 3 4 typedef unsigned char __u_char; typedef unsigned short int __u_short; typedef unsigned int __u_int; typedef unsigned long int __u_long; typedef signed char __int8_t; typedef unsigned char __uint8_t; typedef signed short int __int16_t; typedef unsigned short int __uint16_t; typedef signed int __int32_t; typedef unsigned int __uint32_t; typedef signed long int __int64_t; typedef unsigned long int __uint64_t; typedef __int8_t __int_least8_t; typedef __uint8_t __uint_least8_t; typedef __int16_t __int_least16_t; typedef __uint16_t __uint_least16_t; typedef __int32_t __int_least32_t; typedef __uint32_t __uint_least32_t; typedef __int64_t __int_least64_t; typedef __uint64_t __uint_least64_t; typedef long int __quad_t; typedef unsigned long int __u_quad_t; typedef long int __intmax_t; typedef unsigned long int __uintmax_t; # 141 "/usr/include/riscv64-linux-gnu/bits/types.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/typesizes.h" 1 3 4 # 142 "/usr/include/riscv64-linux-gnu/bits/types.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/time64.h" 1 3 4 # 143 "/usr/include/riscv64-linux-gnu/bits/types.h" 2 3 4 typedef unsigned long int __dev_t; typedef unsigned int __uid_t; typedef unsigned int __gid_t; typedef unsigned long int __ino_t; typedef unsigned long int __ino64_t; typedef unsigned int __mode_t; typedef unsigned int __nlink_t; typedef long int __off_t; typedef long int __off64_t; typedef int __pid_t; typedef struct { int __val[2]; } __fsid_t; typedef long int __clock_t; typedef unsigned long int __rlim_t; typedef unsigned long int __rlim64_t; typedef unsigned int __id_t; typedef long int __time_t; typedef unsigned int __useconds_t; typedef long int __suseconds_t; typedef long int __suseconds64_t; typedef int __daddr_t; typedef int __key_t; typedef int __clockid_t; typedef void * __timer_t; typedef int __blksize_t; typedef long int __blkcnt_t; typedef long int __blkcnt64_t; typedef unsigned long int __fsblkcnt_t; typedef unsigned long int __fsblkcnt64_t; typedef unsigned long int __fsfilcnt_t; typedef unsigned long int __fsfilcnt64_t; typedef long int __fsword_t; typedef long int __ssize_t; typedef long int __syscall_slong_t; typedef unsigned long int __syscall_ulong_t; typedef __off64_t __loff_t; typedef char *__caddr_t; typedef long int __intptr_t; typedef unsigned int __socklen_t; typedef int __sig_atomic_t; # 28 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wchar.h" 1 3 4 # 29 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 30 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdint-intn.h" 1 3 4 # 24 "/usr/include/riscv64-linux-gnu/bits/stdint-intn.h" 3 4 typedef __int8_t int8_t; typedef __int16_t int16_t; typedef __int32_t int32_t; typedef __int64_t int64_t; # 35 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdint-uintn.h" 1 3 4 # 24 "/usr/include/riscv64-linux-gnu/bits/stdint-uintn.h" 3 4 typedef __uint8_t uint8_t; typedef __uint16_t uint16_t; typedef __uint32_t uint32_t; typedef __uint64_t uint64_t; # 38 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdint-least.h" 1 3 4 # 25 "/usr/include/riscv64-linux-gnu/bits/stdint-least.h" 3 4 typedef __int_least8_t int_least8_t; typedef __int_least16_t int_least16_t; typedef __int_least32_t int_least32_t; typedef __int_least64_t int_least64_t; typedef __uint_least8_t uint_least8_t; typedef __uint_least16_t uint_least16_t; typedef __uint_least32_t uint_least32_t; typedef __uint_least64_t uint_least64_t; # 42 "/usr/include/stdint.h" 2 3 4 typedef signed char int_fast8_t; typedef long int int_fast16_t; typedef long int int_fast32_t; typedef long int int_fast64_t; # 60 "/usr/include/stdint.h" 3 4 typedef unsigned char uint_fast8_t; typedef unsigned long int uint_fast16_t; typedef unsigned long int uint_fast32_t; typedef unsigned long int uint_fast64_t; # 76 "/usr/include/stdint.h" 3 4 typedef long int intptr_t; typedef unsigned long int uintptr_t; # 90 "/usr/include/stdint.h" 3 4 typedef __intmax_t intmax_t; typedef __uintmax_t uintmax_t; # 12 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stdint.h" 2 3 4 #pragma GCC diagnostic pop # 48 "/usr/include/c++/15/cstdint" 2 3 namespace std { using ::int8_t; using ::int16_t; using ::int32_t; using ::int64_t; using ::int_fast8_t; using ::int_fast16_t; using ::int_fast32_t; using ::int_fast64_t; using ::int_least8_t; using ::int_least16_t; using ::int_least32_t; using ::int_least64_t; using ::intmax_t; using ::intptr_t; using ::uint8_t; using ::uint16_t; using ::uint32_t; using ::uint64_t; using ::uint_fast8_t; using ::uint_fast16_t; using ::uint_fast32_t; using ::uint_fast64_t; using ::uint_least8_t; using ::uint_least16_t; using ::uint_least32_t; using ::uint_least64_t; using ::uintmax_t; using ::uintptr_t; # 144 "/usr/include/c++/15/cstdint" 3 } # 12 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" 2 # 1 "/usr/include/c++/15/functional" 1 3 # 51 "/usr/include/c++/15/functional" 3 # 1 "/usr/include/c++/15/bits/stl_function.h" 1 3 # 60 "/usr/include/c++/15/bits/stl_function.h" 3 # 1 "/usr/include/c++/15/bits/move.h" 1 3 # 37 "/usr/include/c++/15/bits/move.h" 3 # 1 "/usr/include/c++/15/type_traits" 1 3 # 66 "/usr/include/c++/15/type_traits" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 67 "/usr/include/c++/15/type_traits" 2 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { template class reference_wrapper; # 91 "/usr/include/c++/15/type_traits" 3 template struct integral_constant { static constexpr _Tp value = __v; using value_type = _Tp; using type = integral_constant<_Tp, __v>; constexpr operator value_type() const noexcept { return value; } constexpr value_type operator()() const noexcept { return value; } }; # 111 "/usr/include/c++/15/type_traits" 3 template using __bool_constant = integral_constant; using true_type = __bool_constant; using false_type = __bool_constant; template using bool_constant = __bool_constant<__v>; template struct enable_if { }; template struct enable_if { using type = _Tp; }; template using __enable_if_t = typename enable_if<_Cond, _Tp>::type; template struct __conditional { template using type = _Tp; }; template<> struct __conditional { template using type = _Up; }; template using __conditional_t = typename __conditional<_Cond>::template type<_If, _Else>; template struct __type_identity { using type = _Type; }; template using __type_identity_t = typename __type_identity<_Tp>::type; namespace __detail { template using __first_t = _Tp; template auto __or_fn(int) -> __first_t...>; template auto __or_fn(...) -> true_type; template auto __and_fn(int) -> __first_t...>; template auto __and_fn(...) -> false_type; } template struct __or_ : decltype(__detail::__or_fn<_Bn...>(0)) { }; template struct __and_ : decltype(__detail::__and_fn<_Bn...>(0)) { }; template struct __not_ : __bool_constant { }; template inline constexpr bool __or_v = __or_<_Bn...>::value; template inline constexpr bool __and_v = __and_<_Bn...>::value; namespace __detail { template struct __disjunction_impl { using type = _B1; }; template struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> { using type = typename __disjunction_impl::type; }; template struct __conjunction_impl { using type = _B1; }; template struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> { using type = typename __conjunction_impl::type; }; } template struct conjunction : __detail::__conjunction_impl::type { }; template<> struct conjunction<> : true_type { }; template struct disjunction : __detail::__disjunction_impl::type { }; template<> struct disjunction<> : false_type { }; template struct negation : __not_<_Pp>::type { }; template inline constexpr bool conjunction_v = conjunction<_Bn...>::value; template inline constexpr bool disjunction_v = disjunction<_Bn...>::value; template inline constexpr bool negation_v = negation<_Pp>::value; template struct is_reference; template struct is_function; template struct is_void; template struct remove_cv; template struct is_const; template struct __is_array_unknown_bounds; template constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) { return {}; } template constexpr typename __or_< is_reference<_NestedType>, is_function<_NestedType>, is_void<_NestedType>, __is_array_unknown_bounds<_NestedType> >::type __is_complete_or_unbounded(_TypeIdentity) { return {}; } template using __remove_cv_t = typename remove_cv<_Tp>::type; template struct is_void : public false_type { }; template<> struct is_void : public true_type { }; template<> struct is_void : public true_type { }; template<> struct is_void : public true_type { }; template<> struct is_void : public true_type { }; template struct __is_integral_helper : public false_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; __extension__ template<> struct __is_integral_helper<__int128> : public true_type { }; __extension__ template<> struct __is_integral_helper : public true_type { }; # 465 "/usr/include/c++/15/type_traits" 3 template struct is_integral : public __is_integral_helper<__remove_cv_t<_Tp>>::type { }; template struct __is_floating_point_helper : public false_type { }; template<> struct __is_floating_point_helper : public true_type { }; template<> struct __is_floating_point_helper : public true_type { }; template<> struct __is_floating_point_helper : public true_type { }; # 525 "/usr/include/c++/15/type_traits" 3 template struct is_floating_point : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type { }; template struct is_array : public __bool_constant<__is_array(_Tp)> { }; # 552 "/usr/include/c++/15/type_traits" 3 template struct is_pointer : public __bool_constant<__is_pointer(_Tp)> { }; # 579 "/usr/include/c++/15/type_traits" 3 template struct is_lvalue_reference : public false_type { }; template struct is_lvalue_reference<_Tp&> : public true_type { }; template struct is_rvalue_reference : public false_type { }; template struct is_rvalue_reference<_Tp&&> : public true_type { }; template struct is_member_object_pointer : public __bool_constant<__is_member_object_pointer(_Tp)> { }; # 620 "/usr/include/c++/15/type_traits" 3 template struct is_member_function_pointer : public __bool_constant<__is_member_function_pointer(_Tp)> { }; # 641 "/usr/include/c++/15/type_traits" 3 template struct is_enum : public __bool_constant<__is_enum(_Tp)> { }; template struct is_union : public __bool_constant<__is_union(_Tp)> { }; template struct is_class : public __bool_constant<__is_class(_Tp)> { }; template struct is_function : public __bool_constant<__is_function(_Tp)> { }; # 680 "/usr/include/c++/15/type_traits" 3 template struct is_null_pointer : public false_type { }; template<> struct is_null_pointer : public true_type { }; template<> struct is_null_pointer : public true_type { }; template<> struct is_null_pointer : public true_type { }; template<> struct is_null_pointer : public true_type { }; template struct __is_nullptr_t : public is_null_pointer<_Tp> { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); template struct is_reference : public __bool_constant<__is_reference(_Tp)> { }; # 734 "/usr/include/c++/15/type_traits" 3 template struct is_arithmetic : public __or_, is_floating_point<_Tp>>::type { }; template struct is_fundamental : public __or_, is_void<_Tp>, is_null_pointer<_Tp>>::type { }; template struct is_object : public __bool_constant<__is_object(_Tp)> { }; # 760 "/usr/include/c++/15/type_traits" 3 template struct is_member_pointer; template struct is_scalar : public __or_, is_enum<_Tp>, is_pointer<_Tp>, is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type { }; template struct is_compound : public __bool_constant::value> { }; template struct is_member_pointer : public __bool_constant<__is_member_pointer(_Tp)> { }; # 798 "/usr/include/c++/15/type_traits" 3 template struct is_same; template using __is_one_of = __or_...>; __extension__ template using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, signed char, signed short, signed int, signed long, signed long long , signed __int128 # 823 "/usr/include/c++/15/type_traits" 3 >; __extension__ template using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long , unsigned __int128 # 843 "/usr/include/c++/15/type_traits" 3 >; template using __is_standard_integer = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; template using __void_t = void; template struct is_const : public __bool_constant<__is_const(_Tp)> { }; # 874 "/usr/include/c++/15/type_traits" 3 template struct is_volatile : public __bool_constant<__is_volatile(_Tp)> { }; # 895 "/usr/include/c++/15/type_traits" 3 template struct is_trivial : public __bool_constant<__is_trivial(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_copyable : public __bool_constant<__is_trivially_copyable(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_standard_layout : public __bool_constant<__is_standard_layout(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_pod : public __bool_constant<__is_pod(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct [[__deprecated__]] is_literal_type : public __bool_constant<__is_literal_type(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_empty : public __bool_constant<__is_empty(_Tp)> { }; template struct is_polymorphic : public __bool_constant<__is_polymorphic(_Tp)> { }; template struct is_final : public __bool_constant<__is_final(_Tp)> { }; template struct is_abstract : public __bool_constant<__is_abstract(_Tp)> { }; template::value> struct __is_signed_helper : public false_type { }; template struct __is_signed_helper<_Tp, true> : public __bool_constant<_Tp(-1) < _Tp(0)> { }; template struct is_signed : public __is_signed_helper<_Tp>::type { }; template struct is_unsigned : public __and_, __not_>>::type { }; template _Up __declval(int); template _Tp __declval(long); template auto declval() noexcept -> decltype(__declval<_Tp>(0)); template struct remove_all_extents; template struct __is_array_known_bounds : public false_type { }; template struct __is_array_known_bounds<_Tp[_Size]> : public true_type { }; template struct __is_array_unknown_bounds : public false_type { }; template struct __is_array_unknown_bounds<_Tp[]> : public true_type { }; # 1047 "/usr/include/c++/15/type_traits" 3 struct __do_is_destructible_impl { template().~_Tp())> static true_type __test(int); template static false_type __test(...); }; template struct __is_destructible_impl : public __do_is_destructible_impl { using type = decltype(__test<_Tp>(0)); }; template, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_, is_scalar<_Tp>>::value> struct __is_destructible_safe; template struct __is_destructible_safe<_Tp, false, false> : public __is_destructible_impl::type>::type { }; template struct __is_destructible_safe<_Tp, true, false> : public false_type { }; template struct __is_destructible_safe<_Tp, false, true> : public true_type { }; template struct is_destructible : public __is_destructible_safe<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; struct __do_is_nt_destructible_impl { template static __bool_constant().~_Tp())> __test(int); template static false_type __test(...); }; template struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl { using type = decltype(__test<_Tp>(0)); }; template, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_, is_scalar<_Tp>>::value> struct __is_nt_destructible_safe; template struct __is_nt_destructible_safe<_Tp, false, false> : public __is_nt_destructible_impl::type>::type { }; template struct __is_nt_destructible_safe<_Tp, true, false> : public false_type { }; template struct __is_nt_destructible_safe<_Tp, false, true> : public true_type { }; template struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __is_constructible_impl = __bool_constant<__is_constructible(_Tp, _Args...)>; template struct is_constructible : public __is_constructible_impl<_Tp, _Args...> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_default_constructible : public __is_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __add_lval_ref_t = __add_lvalue_reference(_Tp); # 1191 "/usr/include/c++/15/type_traits" 3 template struct is_copy_constructible : public __is_constructible_impl<_Tp, __add_lval_ref_t> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __add_rval_ref_t = __add_rvalue_reference(_Tp); # 1218 "/usr/include/c++/15/type_traits" 3 template struct is_move_constructible : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __is_nothrow_constructible_impl = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; template struct is_nothrow_constructible : public __is_nothrow_constructible_impl<_Tp, _Args...> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_default_constructible : public __is_nothrow_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_copy_constructible : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_move_constructible : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; template struct is_assignable : public __is_assignable_impl<_Tp, _Up> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_copy_assignable : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_lval_ref_t> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_move_assignable : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __is_nothrow_assignable_impl = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; template struct is_nothrow_assignable : public __is_nothrow_assignable_impl<_Tp, _Up> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_copy_assignable : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, __add_lval_ref_t> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_move_assignable : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __is_trivially_constructible_impl = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; template struct is_trivially_constructible : public __is_trivially_constructible_impl<_Tp, _Args...> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_default_constructible : public __is_trivially_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; # 1370 "/usr/include/c++/15/type_traits" 3 struct __do_is_implicitly_default_constructible_impl { template static void __helper(const _Tp&); template static true_type __test(const _Tp&, decltype(__helper({}))* = 0); static false_type __test(...); }; template struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl { using type = decltype(__test(declval<_Tp>())); }; template struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl<_Tp>::type { }; template struct __is_implicitly_default_constructible : public __and_<__is_constructible_impl<_Tp>, __is_implicitly_default_constructible_safe<_Tp>>::type { }; template struct is_trivially_copy_constructible : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_move_constructible : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template using __is_trivially_assignable_impl = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; template struct is_trivially_assignable : public __is_trivially_assignable_impl<_Tp, _Up> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_copy_assignable : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, __add_lval_ref_t> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_move_assignable : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_destructible : public __and_<__is_destructible_safe<_Tp>, __bool_constant<__has_trivial_destructor(_Tp)>>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct has_virtual_destructor : public __bool_constant<__has_virtual_destructor(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct alignment_of : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct rank : public integral_constant { }; # 1507 "/usr/include/c++/15/type_traits" 3 template struct extent : public integral_constant { }; template struct extent<_Tp[_Size], 0> : public integral_constant { }; template struct extent<_Tp[_Size], _Uint> : public extent<_Tp, _Uint - 1>::type { }; template struct extent<_Tp[], 0> : public integral_constant { }; template struct extent<_Tp[], _Uint> : public extent<_Tp, _Uint - 1>::type { }; template struct is_same : public __bool_constant<__is_same(_Tp, _Up)> { }; # 1549 "/usr/include/c++/15/type_traits" 3 template struct is_base_of : public __bool_constant<__is_base_of(_Base, _Derived)> { }; # 1564 "/usr/include/c++/15/type_traits" 3 template struct is_convertible : public __bool_constant<__is_convertible(_From, _To)> { }; # 1607 "/usr/include/c++/15/type_traits" 3 template using __is_array_convertible = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; # 1667 "/usr/include/c++/15/type_traits" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++14-extensions" template struct __is_nothrow_new_constructible_impl : __bool_constant< noexcept(::new(std::declval()) _Tp(std::declval<_Args>()...)) > { }; template inline constexpr bool __is_nothrow_new_constructible = __and_, __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value; #pragma GCC diagnostic pop template struct remove_const { using type = _Tp; }; template struct remove_const<_Tp const> { using type = _Tp; }; template struct remove_volatile { using type = _Tp; }; template struct remove_volatile<_Tp volatile> { using type = _Tp; }; template struct remove_cv { using type = __remove_cv(_Tp); }; # 1726 "/usr/include/c++/15/type_traits" 3 template struct add_const { using type = _Tp const; }; template struct add_volatile { using type = _Tp volatile; }; template struct add_cv { using type = _Tp const volatile; }; template using remove_const_t = typename remove_const<_Tp>::type; template using remove_volatile_t = typename remove_volatile<_Tp>::type; template using remove_cv_t = typename remove_cv<_Tp>::type; template using add_const_t = typename add_const<_Tp>::type; template using add_volatile_t = typename add_volatile<_Tp>::type; template using add_cv_t = typename add_cv<_Tp>::type; template struct remove_reference { using type = __remove_reference(_Tp); }; # 1788 "/usr/include/c++/15/type_traits" 3 template struct add_lvalue_reference { using type = __add_lval_ref_t<_Tp>; }; template struct add_rvalue_reference { using type = __add_rval_ref_t<_Tp>; }; template using remove_reference_t = typename remove_reference<_Tp>::type; template using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; template using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; template struct __cv_selector; template struct __cv_selector<_Unqualified, false, false> { using __type = _Unqualified; }; template struct __cv_selector<_Unqualified, false, true> { using __type = volatile _Unqualified; }; template struct __cv_selector<_Unqualified, true, false> { using __type = const _Unqualified; }; template struct __cv_selector<_Unqualified, true, true> { using __type = const volatile _Unqualified; }; template::value, bool _IsVol = is_volatile<_Qualified>::value> class __match_cv_qualifiers { using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>; public: using __type = typename __match::__type; }; template struct __make_unsigned { using __type = _Tp; }; template<> struct __make_unsigned { using __type = unsigned char; }; template<> struct __make_unsigned { using __type = unsigned char; }; template<> struct __make_unsigned { using __type = unsigned short; }; template<> struct __make_unsigned { using __type = unsigned int; }; template<> struct __make_unsigned { using __type = unsigned long; }; template<> struct __make_unsigned { using __type = unsigned long long; }; __extension__ template<> struct __make_unsigned<__int128> { using __type = unsigned __int128; }; # 1901 "/usr/include/c++/15/type_traits" 3 template::value, bool _IsEnum = __is_enum(_Tp)> class __make_unsigned_selector; template class __make_unsigned_selector<_Tp, true, false> { using __unsigned_type = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; public: using __type = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; }; class __make_unsigned_selector_base { protected: template struct _List { }; template struct _List<_Tp, _Up...> : _List<_Up...> { static constexpr size_t __size = sizeof(_Tp); }; template struct __select; template struct __select<_Sz, _List<_Uint, _UInts...>, true> { using __type = _Uint; }; template struct __select<_Sz, _List<_Uint, _UInts...>, false> : __select<_Sz, _List<_UInts...>> { }; }; template class __make_unsigned_selector<_Tp, false, true> : __make_unsigned_selector_base { using _UInts = _List; using __unsigned_type = typename __select::__type; public: using __type = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; # 1975 "/usr/include/c++/15/type_traits" 3 template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template struct make_unsigned { using type = typename __make_unsigned_selector<_Tp>::__type; }; template<> struct make_unsigned; template<> struct make_unsigned; template<> struct make_unsigned; template<> struct make_unsigned; template struct __make_signed { using __type = _Tp; }; template<> struct __make_signed { using __type = signed char; }; template<> struct __make_signed { using __type = signed char; }; template<> struct __make_signed { using __type = signed short; }; template<> struct __make_signed { using __type = signed int; }; template<> struct __make_signed { using __type = signed long; }; template<> struct __make_signed { using __type = signed long long; }; __extension__ template<> struct __make_signed { using __type = __int128; }; # 2061 "/usr/include/c++/15/type_traits" 3 template::value, bool _IsEnum = __is_enum(_Tp)> class __make_signed_selector; template class __make_signed_selector<_Tp, true, false> { using __signed_type = typename __make_signed<__remove_cv_t<_Tp>>::__type; public: using __type = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; }; template class __make_signed_selector<_Tp, false, true> { using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type; public: using __type = typename __make_signed_selector<__unsigned_type>::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; # 2107 "/usr/include/c++/15/type_traits" 3 template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template struct make_signed { using type = typename __make_signed_selector<_Tp>::__type; }; template<> struct make_signed; template<> struct make_signed; template<> struct make_signed; template<> struct make_signed; template using make_signed_t = typename make_signed<_Tp>::type; template using make_unsigned_t = typename make_unsigned<_Tp>::type; template struct remove_extent { using type = __remove_extent(_Tp); }; # 2169 "/usr/include/c++/15/type_traits" 3 template struct remove_all_extents { using type = __remove_all_extents(_Tp); }; # 2188 "/usr/include/c++/15/type_traits" 3 template using remove_extent_t = typename remove_extent<_Tp>::type; template using remove_all_extents_t = typename remove_all_extents<_Tp>::type; template struct remove_pointer { using type = __remove_pointer(_Tp); }; # 2220 "/usr/include/c++/15/type_traits" 3 template struct add_pointer { using type = __add_pointer(_Tp); }; # 2248 "/usr/include/c++/15/type_traits" 3 template using remove_pointer_t = typename remove_pointer<_Tp>::type; template using add_pointer_t = typename add_pointer<_Tp>::type; struct __attribute__((__aligned__)) __aligned_storage_max_align_t { }; constexpr size_t __aligned_storage_default_alignment([[__maybe_unused__]] size_t __len) { # 2279 "/usr/include/c++/15/type_traits" 3 return alignof(__aligned_storage_max_align_t); } # 2315 "/usr/include/c++/15/type_traits" 3 template struct aligned_storage { struct type { alignas(_Align) unsigned char __data[_Len]; }; }; template struct __strictest_alignment { static const size_t _S_alignment = 0; static const size_t _S_size = 0; }; template struct __strictest_alignment<_Tp, _Types...> { static const size_t _S_alignment = alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; static const size_t _S_size = sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" # 2360 "/usr/include/c++/15/type_traits" 3 template struct aligned_union { private: static_assert(sizeof...(_Types) != 0, "At least one type is required"); using __strictest = __strictest_alignment<_Types...>; static const size_t _S_len = _Len > __strictest::_S_size ? _Len : __strictest::_S_size; public: static const size_t alignment_value = __strictest::_S_alignment; using type = typename aligned_storage<_S_len, alignment_value>::type; }; template const size_t aligned_union<_Len, _Types...>::alignment_value; #pragma GCC diagnostic pop template struct decay { using type = __decay(_Tp); }; # 2425 "/usr/include/c++/15/type_traits" 3 template struct __strip_reference_wrapper { using __type = _Tp; }; template struct __strip_reference_wrapper > { using __type = _Tp&; }; template using __decay_t = typename decay<_Tp>::type; template using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; template using _Require = __enable_if_t<__and_<_Cond...>::value>; template using __remove_cvref_t = typename remove_cv::type>::type; template struct conditional { using type = _Iftrue; }; template struct conditional { using type = _Iffalse; }; template struct common_type; # 2481 "/usr/include/c++/15/type_traits" 3 template struct __success_type { using type = _Tp; }; struct __failure_type { }; struct __do_common_type_impl { template using __cond_t = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); template static __success_type<__decay_t<__cond_t<_Tp, _Up>>> _S_test(int); # 2508 "/usr/include/c++/15/type_traits" 3 template static __failure_type _S_test_2(...); template static decltype(_S_test_2<_Tp, _Up>(0)) _S_test(...); }; template<> struct common_type<> { }; template struct common_type<_Tp0> : public common_type<_Tp0, _Tp0> { }; template, typename _Dp2 = __decay_t<_Tp2>> struct __common_type_impl { using type = common_type<_Dp1, _Dp2>; }; template struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> : private __do_common_type_impl { using type = decltype(_S_test<_Tp1, _Tp2>(0)); }; template struct common_type<_Tp1, _Tp2> : public __common_type_impl<_Tp1, _Tp2>::type { }; template struct __common_type_pack { }; template struct __common_type_fold; template struct common_type<_Tp1, _Tp2, _Rp...> : public __common_type_fold, __common_type_pack<_Rp...>> { }; template struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, __void_t> : public common_type { }; template struct __common_type_fold<_CTp, _Rp, void> { }; template struct __underlying_type_impl { using type = __underlying_type(_Tp); }; template struct __underlying_type_impl<_Tp, false> { }; template struct underlying_type : public __underlying_type_impl<_Tp> { }; template struct __declval_protector { static const bool __stop = false; }; template auto declval() noexcept -> decltype(__declval<_Tp>(0)) { static_assert(__declval_protector<_Tp>::__stop, "declval() must not be used!"); return __declval<_Tp>(0); } template struct result_of; struct __invoke_memfun_ref { }; struct __invoke_memfun_deref { }; struct __invoke_memobj_ref { }; struct __invoke_memobj_deref { }; struct __invoke_other { }; template struct __result_of_success : __success_type<_Tp> { using __invoke_type = _Tag; }; struct __result_of_memfun_ref_impl { template static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) ), __invoke_memfun_ref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memfun_ref : private __result_of_memfun_ref_impl { using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); }; struct __result_of_memfun_deref_impl { template static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) ), __invoke_memfun_deref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memfun_deref : private __result_of_memfun_deref_impl { using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0)); }; struct __result_of_memobj_ref_impl { template static __result_of_success().*std::declval<_Fp>() ), __invoke_memobj_ref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memobj_ref : private __result_of_memobj_ref_impl { using type = decltype(_S_test<_MemPtr, _Arg>(0)); }; struct __result_of_memobj_deref_impl { template static __result_of_success()).*std::declval<_Fp>() ), __invoke_memobj_deref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memobj_deref : private __result_of_memobj_deref_impl { using type = decltype(_S_test<_MemPtr, _Arg>(0)); }; template struct __result_of_memobj; template struct __result_of_memobj<_Res _Class::*, _Arg> { using _Argval = __remove_cvref_t<_Arg>; using _MemPtr = _Res _Class::*; using type = typename __conditional_t<__or_, is_base_of<_Class, _Argval>>::value, __result_of_memobj_ref<_MemPtr, _Arg>, __result_of_memobj_deref<_MemPtr, _Arg> >::type; }; template struct __result_of_memfun; template struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> { using _Argval = typename remove_reference<_Arg>::type; using _MemPtr = _Res _Class::*; using type = typename __conditional_t::value, __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, __result_of_memfun_deref<_MemPtr, _Arg, _Args...> >::type; }; template> struct __inv_unwrap { using type = _Tp; }; template struct __inv_unwrap<_Tp, reference_wrapper<_Up>> { using type = _Up&; }; template struct __result_of_impl { using type = __failure_type; }; template struct __result_of_impl : public __result_of_memobj<__decay_t<_MemPtr>, typename __inv_unwrap<_Arg>::type> { }; template struct __result_of_impl : public __result_of_memfun<__decay_t<_MemPtr>, typename __inv_unwrap<_Arg>::type, _Args...> { }; struct __result_of_other_impl { template static __result_of_success()(std::declval<_Args>()...) ), __invoke_other> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_impl : private __result_of_other_impl { using type = decltype(_S_test<_Functor, _ArgTypes...>(0)); }; template struct __invoke_result : public __result_of_impl< is_member_object_pointer< typename remove_reference<_Functor>::type >::value, is_member_function_pointer< typename remove_reference<_Functor>::type >::value, _Functor, _ArgTypes... >::type { }; template using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type; template struct result_of<_Functor(_ArgTypes...)> : public __invoke_result<_Functor, _ArgTypes...> { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; template using aligned_union_t = typename aligned_union<_Len, _Types...>::type; #pragma GCC diagnostic pop template using decay_t = typename decay<_Tp>::type; template using enable_if_t = typename enable_if<_Cond, _Tp>::type; template using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; template using common_type_t = typename common_type<_Tp...>::type; template using underlying_type_t = typename underlying_type<_Tp>::type; template using result_of_t = typename result_of<_Tp>::type; template using void_t = void; # 2885 "/usr/include/c++/15/type_traits" 3 template class _Op, typename... _Args> struct __detector { using type = _Default; using __is_detected = false_type; }; template class _Op, typename... _Args> struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> { using type = _Op<_Args...>; using __is_detected = true_type; }; template class _Op, typename... _Args> using __detected_or = __detector<_Default, void, _Op, _Args...>; template class _Op, typename... _Args> using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type; # 2927 "/usr/include/c++/15/type_traits" 3 template struct __is_swappable; template struct __is_nothrow_swappable; template struct __is_tuple_like_impl : false_type { }; template struct __is_tuple_like : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type { }; template inline _Require<__not_<__is_tuple_like<_Tp>>, is_move_constructible<_Tp>, is_move_assignable<_Tp>> swap(_Tp&, _Tp&) noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value); template inline __enable_if_t<__is_swappable<_Tp>::value> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) noexcept(__is_nothrow_swappable<_Tp>::value); namespace __swappable_details { using std::swap; struct __do_is_swappable_impl { template(), std::declval<_Tp&>()))> static true_type __test(int); template static false_type __test(...); }; struct __do_is_nothrow_swappable_impl { template static __bool_constant< noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) > __test(int); template static false_type __test(...); }; } template struct __is_swappable_impl : public __swappable_details::__do_is_swappable_impl { using type = decltype(__test<_Tp>(0)); }; template struct __is_nothrow_swappable_impl : public __swappable_details::__do_is_nothrow_swappable_impl { using type = decltype(__test<_Tp>(0)); }; template struct __is_swappable : public __is_swappable_impl<_Tp>::type { }; template struct __is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type { }; template struct is_swappable : public __is_swappable_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template inline constexpr bool is_swappable_v = is_swappable<_Tp>::value; template inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value; namespace __swappable_with_details { using std::swap; struct __do_is_swappable_with_impl { template(), std::declval<_Up>())), typename = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> static true_type __test(int); template static false_type __test(...); }; struct __do_is_nothrow_swappable_with_impl { template static __bool_constant< noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) && noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) > __test(int); template static false_type __test(...); }; } template struct __is_swappable_with_impl : public __swappable_with_details::__do_is_swappable_with_impl { using type = decltype(__test<_Tp, _Up>(0)); }; template struct __is_swappable_with_impl<_Tp&, _Tp&> : public __swappable_details::__do_is_swappable_impl { using type = decltype(__test<_Tp&>(0)); }; template struct __is_nothrow_swappable_with_impl : public __swappable_with_details::__do_is_nothrow_swappable_with_impl { using type = decltype(__test<_Tp, _Up>(0)); }; template struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> : public __swappable_details::__do_is_nothrow_swappable_impl { using type = decltype(__test<_Tp&>(0)); }; template struct is_swappable_with : public __is_swappable_with_impl<_Tp, _Up>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "first template argument must be a complete class or an unbounded array"); static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), "second template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_swappable_with : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "first template argument must be a complete class or an unbounded array"); static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), "second template argument must be a complete class or an unbounded array"); }; template inline constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value; template inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value; # 3149 "/usr/include/c++/15/type_traits" 3 template::value, typename = void> struct __is_invocable_impl : false_type { using __nothrow_conv = false_type; }; template struct __is_invocable_impl<_Result, _Ret, true, __void_t> : true_type { using __nothrow_conv = true_type; }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" template struct __is_invocable_impl<_Result, _Ret, false, __void_t> { private: using _Res_t = typename _Result::type; static _Res_t _S_get() noexcept; template static void _S_conv(__type_identity_t<_Tp>) noexcept; template(_S_get())), typename = decltype(_S_conv<_Tp>(_S_get())), bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) > static __bool_constant<_Nothrow && !_Dangle> _S_test(int); template static false_type _S_test(...); public: using type = decltype(_S_test<_Ret, true>(1)); using __nothrow_conv = decltype(_S_test<_Ret>(1)); }; #pragma GCC diagnostic pop template struct __is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type { }; template constexpr bool __call_is_nt(__invoke_memfun_ref) { using _Up = typename __inv_unwrap<_Tp>::type; return noexcept((std::declval<_Up>().*std::declval<_Fn>())( std::declval<_Args>()...)); } template constexpr bool __call_is_nt(__invoke_memfun_deref) { return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( std::declval<_Args>()...)); } template constexpr bool __call_is_nt(__invoke_memobj_ref) { using _Up = typename __inv_unwrap<_Tp>::type; return noexcept(std::declval<_Up>().*std::declval<_Fn>()); } template constexpr bool __call_is_nt(__invoke_memobj_deref) { return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); } template constexpr bool __call_is_nt(__invoke_other) { return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); } template struct __call_is_nothrow : __bool_constant< std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) > { }; template using __call_is_nothrow_ = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; template struct __is_nothrow_invocable : __and_<__is_invocable<_Fn, _Args...>, __call_is_nothrow_<_Fn, _Args...>>::type { }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" struct __nonesuchbase {}; struct __nonesuch : private __nonesuchbase { ~__nonesuch() = delete; __nonesuch(__nonesuch const&) = delete; void operator=(__nonesuch const&) = delete; }; #pragma GCC diagnostic pop template struct invoke_result : public __invoke_result<_Functor, _ArgTypes...> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), "_Functor must be a complete class or an unbounded array"); static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{}) && ...), "each argument type must be a complete class or an unbounded array"); }; template using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; template struct is_invocable : public __bool_constant<__is_invocable(_Fn, _ArgTypes...)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{}) && ...), "each argument type must be a complete class or an unbounded array"); }; template struct is_invocable_r : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{}) && ...), "each argument type must be a complete class or an unbounded array"); static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), "_Ret must be a complete class or an unbounded array"); }; template struct is_nothrow_invocable : public __bool_constant<__is_nothrow_invocable(_Fn, _ArgTypes...)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{}) && ...), "each argument type must be a complete class or an unbounded array"); }; template using __is_nt_invocable_impl = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; template struct is_nothrow_invocable_r : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{}) && ...), "each argument type must be a complete class or an unbounded array"); static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), "_Ret must be a complete class or an unbounded array"); }; # 3385 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_void_v = is_void<_Tp>::value; template inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; template inline constexpr bool is_integral_v = is_integral<_Tp>::value; template inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; template inline constexpr bool is_array_v = __is_array(_Tp); # 3407 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_pointer_v = __is_pointer(_Tp); # 3422 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_lvalue_reference_v = false; template inline constexpr bool is_lvalue_reference_v<_Tp&> = true; template inline constexpr bool is_rvalue_reference_v = false; template inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; template inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp); template inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp); template inline constexpr bool is_enum_v = __is_enum(_Tp); template inline constexpr bool is_union_v = __is_union(_Tp); template inline constexpr bool is_class_v = __is_class(_Tp); template inline constexpr bool is_reference_v = __is_reference(_Tp); # 3471 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; template inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; template inline constexpr bool is_object_v = __is_object(_Tp); template inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; template inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>; template inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); template inline constexpr bool is_const_v = __is_const(_Tp); # 3508 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_function_v = __is_function(_Tp); # 3520 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_volatile_v = __is_volatile(_Tp); template inline constexpr bool is_trivial_v = __is_trivial(_Tp); template inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); template inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); template inline constexpr bool is_pod_v = __is_pod(_Tp); template [[__deprecated__]] inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); template inline constexpr bool is_empty_v = __is_empty(_Tp); template inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); template inline constexpr bool is_abstract_v = __is_abstract(_Tp); template inline constexpr bool is_final_v = __is_final(_Tp); template inline constexpr bool is_signed_v = is_signed<_Tp>::value; template inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; template inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); template inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); template inline constexpr bool is_copy_constructible_v = __is_constructible(_Tp, __add_lval_ref_t); template inline constexpr bool is_move_constructible_v = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); template inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); template inline constexpr bool is_copy_assignable_v = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); template inline constexpr bool is_move_assignable_v = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); template inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; template inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...); template inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp); template inline constexpr bool is_trivially_copy_constructible_v = __is_trivially_constructible(_Tp, __add_lval_ref_t); template inline constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); template inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Up); template inline constexpr bool is_trivially_copy_assignable_v = __is_trivially_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); template inline constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); # 3620 "/usr/include/c++/15/type_traits" 3 template inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value; template inline constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Tp, _Args...); template inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp); template inline constexpr bool is_nothrow_copy_constructible_v = __is_nothrow_constructible(_Tp, __add_lval_ref_t); template inline constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); template inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Up); template inline constexpr bool is_nothrow_copy_assignable_v = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); template inline constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); template inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; template inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp); template inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; template inline constexpr size_t rank_v = __array_rank(_Tp); # 3673 "/usr/include/c++/15/type_traits" 3 template inline constexpr size_t extent_v = 0; template inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; template inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; template inline constexpr size_t extent_v<_Tp[], 0> = 0; template inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; template inline constexpr bool is_same_v = __is_same(_Tp, _Up); template inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); template inline constexpr bool is_convertible_v = __is_convertible(_From, _To); template inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; template inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value; template inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value; template inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; template struct has_unique_object_representations : bool_constant<__has_unique_object_representations( remove_cv_t> )> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value; template struct is_aggregate : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { }; template inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); # 4191 "/usr/include/c++/15/type_traits" 3 } } # 38 "/usr/include/c++/15/bits/move.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template __attribute__((__always_inline__)) inline constexpr _Tp* __addressof(_Tp& __r) noexcept { return __builtin_addressof(__r); } # 69 "/usr/include/c++/15/bits/move.h" 3 template [[__nodiscard__,__gnu__::__always_inline__]] constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept { return static_cast<_Tp&&>(__t); } # 82 "/usr/include/c++/15/bits/move.h" 3 template [[__nodiscard__,__gnu__::__always_inline__]] constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcept { static_assert(!std::is_lvalue_reference<_Tp>::value, "std::forward must not be used to convert an rvalue to an lvalue"); return static_cast<_Tp&&>(__t); } # 135 "/usr/include/c++/15/bits/move.h" 3 template [[__nodiscard__,__gnu__::__always_inline__]] constexpr typename std::remove_reference<_Tp>::type&& move(_Tp&& __t) noexcept { return static_cast::type&&>(__t); } template struct __move_if_noexcept_cond : public __and_<__not_>, is_copy_constructible<_Tp>>::type { }; # 156 "/usr/include/c++/15/bits/move.h" 3 template [[__nodiscard__,__gnu__::__always_inline__]] constexpr __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> move_if_noexcept(_Tp& __x) noexcept { return std::move(__x); } # 173 "/usr/include/c++/15/bits/move.h" 3 template [[__nodiscard__,__gnu__::__always_inline__]] inline constexpr _Tp* addressof(_Tp& __r) noexcept { return std::__addressof(__r); } template const _Tp* addressof(const _Tp&&) = delete; template inline _Tp __exchange(_Tp& __obj, _Up&& __new_val) { _Tp __old_val = std::move(__obj); __obj = std::forward<_Up>(__new_val); return __old_val; } # 217 "/usr/include/c++/15/bits/move.h" 3 template inline typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value>::type swap(_Tp& __a, _Tp& __b) noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) { _Tp __tmp = std::move(__a); __a = std::move(__b); __b = std::move(__tmp); } template inline typename enable_if<__is_swappable<_Tp>::value>::type swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) noexcept(__is_nothrow_swappable<_Tp>::value) { for (size_t __n = 0; __n < _Nm; ++__n) swap(__a[__n], __b[__n]); } } # 61 "/usr/include/c++/15/bits/stl_function.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 116 "/usr/include/c++/15/bits/stl_function.h" 3 template struct unary_function { typedef _Arg argument_type; typedef _Result result_type; } __attribute__ ((__deprecated__)); template struct binary_function { typedef _Arg1 first_argument_type; typedef _Arg2 second_argument_type; typedef _Result result_type; } __attribute__ ((__deprecated__)); # 157 "/usr/include/c++/15/bits/stl_function.h" 3 struct __is_transparent; template struct plus; template struct minus; template struct multiplies; template struct divides; template struct modulus; template struct negate; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct plus : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } }; template struct minus : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; } }; template struct multiplies : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } }; template struct divides : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } }; template struct modulus : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } }; template struct negate : public unary_function<_Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x) const { return -__x; } }; #pragma GCC diagnostic pop template<> struct plus { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct minus { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct multiplies { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct divides { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct modulus { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct negate { template constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(-std::forward<_Tp>(__t))) -> decltype(-std::forward<_Tp>(__t)) { return -std::forward<_Tp>(__t); } typedef __is_transparent is_transparent; }; # 346 "/usr/include/c++/15/bits/stl_function.h" 3 template struct equal_to; template struct not_equal_to; template struct greater; template struct less; template struct greater_equal; template struct less_equal; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct equal_to : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; } }; template struct not_equal_to : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } }; template struct greater : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } }; template struct less : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; } }; template struct greater_equal : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } }; template struct less_equal : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } }; template struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (std::__is_constant_evaluated()) return __x > __y; return (long unsigned int)__x > (long unsigned int)__y; } }; template struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (std::__is_constant_evaluated()) return __x < __y; return (long unsigned int)__x < (long unsigned int)__y; } }; template struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (std::__is_constant_evaluated()) return __x >= __y; return (long unsigned int)__x >= (long unsigned int)__y; } }; template struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (std::__is_constant_evaluated()) return __x <= __y; return (long unsigned int)__x <= (long unsigned int)__y; } }; #pragma GCC diagnostic pop template<> struct equal_to { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct not_equal_to { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct greater { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) { return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), __ptr_cmp<_Tp, _Up>{}); } template constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return greater>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return greater{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; template<> struct less { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) { return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), __ptr_cmp<_Tp, _Up>{}); } template constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return less>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return less{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; template<> struct greater_equal { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) { return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), __ptr_cmp<_Tp, _Up>{}); } template constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return greater_equal>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return greater_equal{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; template<> struct less_equal { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) { return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), __ptr_cmp<_Tp, _Up>{}); } template constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return less_equal>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return less_equal{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; # 778 "/usr/include/c++/15/bits/stl_function.h" 3 template struct logical_and; template struct logical_or; template struct logical_not; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct logical_and : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } }; template struct logical_or : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } }; template struct logical_not : public unary_function<_Tp, bool> { constexpr bool operator()(const _Tp& __x) const { return !__x; } }; #pragma GCC diagnostic pop template<> struct logical_and { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct logical_or { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct logical_not { template constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(!std::forward<_Tp>(__t))) -> decltype(!std::forward<_Tp>(__t)) { return !std::forward<_Tp>(__t); } typedef __is_transparent is_transparent; }; template struct bit_and; template struct bit_or; template struct bit_xor; template struct bit_not; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct bit_and : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x & __y; } }; template struct bit_or : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x | __y; } }; template struct bit_xor : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x ^ __y; } }; template struct bit_not : public unary_function<_Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x) const { return ~__x; } }; #pragma GCC diagnostic pop template <> struct bit_and { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template <> struct bit_or { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template <> struct bit_xor { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template <> struct bit_not { template constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(~std::forward<_Tp>(__t))) -> decltype(~std::forward<_Tp>(__t)) { return ~std::forward<_Tp>(__t); } typedef __is_transparent is_transparent; }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" # 1020 "/usr/include/c++/15/bits/stl_function.h" 3 template class [[__deprecated__]] unary_negate : public unary_function { protected: _Predicate _M_pred; public: constexpr explicit unary_negate(const _Predicate& __x) : _M_pred(__x) { } constexpr bool operator()(const typename _Predicate::argument_type& __x) const { return !_M_pred(__x); } }; template __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) constexpr inline unary_negate<_Predicate> not1(const _Predicate& __pred) { return unary_negate<_Predicate>(__pred); } template class [[__deprecated__]] binary_negate : public binary_function { protected: _Predicate _M_pred; public: constexpr explicit binary_negate(const _Predicate& __x) : _M_pred(__x) { } constexpr bool operator()(const typename _Predicate::first_argument_type& __x, const typename _Predicate::second_argument_type& __y) const { return !_M_pred(__x, __y); } }; template __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) constexpr inline binary_negate<_Predicate> not2(const _Predicate& __pred) { return binary_negate<_Predicate>(__pred); } # 1101 "/usr/include/c++/15/bits/stl_function.h" 3 template class pointer_to_unary_function : public unary_function<_Arg, _Result> { protected: _Result (*_M_ptr)(_Arg); public: pointer_to_unary_function() { } explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) { } _Result operator()(_Arg __x) const { return _M_ptr(__x); } } __attribute__ ((__deprecated__)); template __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg)) { return pointer_to_unary_function<_Arg, _Result>(__x); } template class pointer_to_binary_function : public binary_function<_Arg1, _Arg2, _Result> { protected: _Result (*_M_ptr)(_Arg1, _Arg2); public: pointer_to_binary_function() { } explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) : _M_ptr(__x) { } _Result operator()(_Arg1 __x, _Arg2 __y) const { return _M_ptr(__x, __y); } } __attribute__ ((__deprecated__)); template __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) inline pointer_to_binary_function<_Arg1, _Arg2, _Result> ptr_fun(_Result (*__x)(_Arg1, _Arg2)) { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } template struct _Identity : public unary_function<_Tp, _Tp> { _Tp& operator()(_Tp& __x) const { return __x; } const _Tp& operator()(const _Tp& __x) const { return __x; } }; template struct _Identity : _Identity<_Tp> { }; template struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { typename _Pair::first_type& operator()(_Pair& __x) const { return __x.first; } const typename _Pair::first_type& operator()(const _Pair& __x) const { return __x.first; } template typename _Pair2::first_type& operator()(_Pair2& __x) const { return __x.first; } template const typename _Pair2::first_type& operator()(const _Pair2& __x) const { return __x.first; } }; template struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type> { typename _Pair::second_type& operator()(_Pair& __x) const { return __x.second; } const typename _Pair::second_type& operator()(const _Pair& __x) const { return __x.second; } }; # 1228 "/usr/include/c++/15/bits/stl_function.h" 3 template class mem_fun_t : public unary_function<_Tp*, _Ret> { public: explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) { } _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); } private: _Ret (_Tp::*_M_f)(); } __attribute__ ((__deprecated__)); template class const_mem_fun_t : public unary_function { public: explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) { } _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); } private: _Ret (_Tp::*_M_f)() const; } __attribute__ ((__deprecated__)); template class mem_fun_ref_t : public unary_function<_Tp, _Ret> { public: explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) { } _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); } private: _Ret (_Tp::*_M_f)(); } __attribute__ ((__deprecated__)); template class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> { public: explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) { } _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); } private: _Ret (_Tp::*_M_f)() const; } __attribute__ ((__deprecated__)); template class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> { public: explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) { } _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg); } __attribute__ ((__deprecated__)); template class const_mem_fun1_t : public binary_function { public: explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) { } _Ret operator()(const _Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg) const; } __attribute__ ((__deprecated__)); template class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { public: explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) { } _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg); } __attribute__ ((__deprecated__)); template class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { public: explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) { } _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg) const; } __attribute__ ((__deprecated__)); template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)()) { return mem_fun_t<_Ret, _Tp>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline const_mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)() const) { return const_mem_fun_t<_Ret, _Tp>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)()) { return mem_fun_ref_t<_Ret, _Tp>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline const_mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)() const) { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline const_mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } template __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } #pragma GCC diagnostic pop template> struct __has_is_transparent { }; template struct __has_is_transparent<_Func, _SfinaeType, __void_t> { typedef void type; }; template using __has_is_transparent_t = typename __has_is_transparent<_Func, _SfinaeType>::type; # 1437 "/usr/include/c++/15/bits/stl_function.h" 3 } # 1 "/usr/include/c++/15/backward/binders.h" 1 3 # 60 "/usr/include/c++/15/backward/binders.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" namespace std __attribute__ ((__visibility__ ("default"))) { # 107 "/usr/include/c++/15/backward/binders.h" 3 template class binder1st : public unary_function { protected: _Operation op; typename _Operation::first_argument_type value; public: binder1st(const _Operation& __x, const typename _Operation::first_argument_type& __y) : op(__x), value(__y) { } typename _Operation::result_type operator()(const typename _Operation::second_argument_type& __x) const { return op(value, __x); } typename _Operation::result_type operator()(typename _Operation::second_argument_type& __x) const { return op(value, __x); } } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); template __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) inline binder1st<_Operation> bind1st(const _Operation& __fn, const _Tp& __x) { typedef typename _Operation::first_argument_type _Arg1_type; return binder1st<_Operation>(__fn, _Arg1_type(__x)); } template class binder2nd : public unary_function { protected: _Operation op; typename _Operation::second_argument_type value; public: binder2nd(const _Operation& __x, const typename _Operation::second_argument_type& __y) : op(__x), value(__y) { } typename _Operation::result_type operator()(const typename _Operation::first_argument_type& __x) const { return op(__x, value); } typename _Operation::result_type operator()(typename _Operation::first_argument_type& __x) const { return op(__x, value); } } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); template __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) inline binder2nd<_Operation> bind2nd(const _Operation& __fn, const _Tp& __x) { typedef typename _Operation::second_argument_type _Arg2_type; return binder2nd<_Operation>(__fn, _Arg2_type(__x)); } } #pragma GCC diagnostic pop # 1442 "/usr/include/c++/15/bits/stl_function.h" 2 3 # 52 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/tuple" 1 3 # 40 "/usr/include/c++/15/tuple" 3 # 1 "/usr/include/c++/15/bits/stl_pair.h" 1 3 # 62 "/usr/include/c++/15/bits/stl_pair.h" 3 # 1 "/usr/include/c++/15/bits/utility.h" 1 3 # 45 "/usr/include/c++/15/bits/utility.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct tuple_size; template::type, typename = typename enable_if::value>::type, size_t = tuple_size<_Tp>::value> using __enable_if_has_tuple_size = _Tp; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_size> : public tuple_size<_Tp> { }; template inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; template struct tuple_element; template using __tuple_element_t = typename tuple_element<__i, _Tp>::type; template struct tuple_element<__i, const _Tp> { using type = const __tuple_element_t<__i, _Tp>; }; template struct tuple_element<__i, volatile _Tp> { using type = volatile __tuple_element_t<__i, _Tp>; }; template struct tuple_element<__i, const volatile _Tp> { using type = const volatile __tuple_element_t<__i, _Tp>; }; template constexpr size_t __find_uniq_type_in_pack() { constexpr size_t __sz = sizeof...(_Types); constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; size_t __n = __sz; for (size_t __i = 0; __i < __sz; ++__i) { if (__found[__i]) { if (__n < __sz) return __sz; __n = __i; } } return __n; } # 136 "/usr/include/c++/15/bits/utility.h" 3 template using tuple_element_t = typename tuple_element<__i, _Tp>::type; template struct _Index_tuple { }; template struct _Build_index_tuple { # 156 "/usr/include/c++/15/bits/utility.h" 3 using __type = _Index_tuple<__integer_pack(_Num)...>; }; template struct integer_sequence { typedef _Tp value_type; static constexpr size_t size() noexcept { return sizeof...(_Idx); } }; template using make_integer_sequence = integer_sequence<_Tp, __integer_pack(_Num)...>; template using index_sequence = integer_sequence; template using make_index_sequence = make_integer_sequence; template using index_sequence_for = make_index_sequence; struct in_place_t { explicit in_place_t() = default; }; inline constexpr in_place_t in_place{}; template struct in_place_type_t { explicit in_place_type_t() = default; }; template inline constexpr in_place_type_t<_Tp> in_place_type{}; template struct in_place_index_t { explicit in_place_index_t() = default; }; template inline constexpr in_place_index_t<_Idx> in_place_index{}; template inline constexpr bool __is_in_place_type_v = false; template inline constexpr bool __is_in_place_type_v> = true; template inline constexpr bool __is_in_place_index_v = false; template inline constexpr bool __is_in_place_index_v> = true; template struct _Nth_type { using type = __type_pack_element<_Np, _Types...>; }; # 284 "/usr/include/c++/15/bits/utility.h" 3 struct _Swallow_assign { template constexpr const _Swallow_assign& operator=(const _Tp&) const noexcept { return *this; } }; # 309 "/usr/include/c++/15/bits/utility.h" 3 inline constexpr _Swallow_assign ignore{}; # 319 "/usr/include/c++/15/bits/utility.h" 3 } # 63 "/usr/include/c++/15/bits/stl_pair.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 79 "/usr/include/c++/15/bits/stl_pair.h" 3 struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); template struct pair; template class tuple; template struct array; template struct _Index_tuple; template class complex; template constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& get(pair<_Tp1, _Tp2>& __in) noexcept; template constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& get(pair<_Tp1, _Tp2>&& __in) noexcept; template constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& get(const pair<_Tp1, _Tp2>& __in) noexcept; template constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& get(const pair<_Tp1, _Tp2>&& __in) noexcept; template constexpr __tuple_element_t<__i, tuple<_Elements...>>& get(tuple<_Elements...>& __t) noexcept; template constexpr const __tuple_element_t<__i, tuple<_Elements...>>& get(const tuple<_Elements...>& __t) noexcept; template constexpr __tuple_element_t<__i, tuple<_Elements...>>&& get(tuple<_Elements...>&& __t) noexcept; template constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& get(const tuple<_Elements...>&& __t) noexcept; template constexpr _Tp& get(array<_Tp, _Nm>&) noexcept; template constexpr _Tp&& get(array<_Tp, _Nm>&&) noexcept; template constexpr const _Tp& get(const array<_Tp, _Nm>&) noexcept; template constexpr const _Tp&& get(const array<_Tp, _Nm>&&) noexcept; # 176 "/usr/include/c++/15/bits/stl_pair.h" 3 template struct _PCC { template static constexpr bool _ConstructiblePair() { return __and_, is_constructible<_T2, const _U2&>>::value; } template static constexpr bool _ImplicitlyConvertiblePair() { return __and_, is_convertible>::value; } template static constexpr bool _MoveConstructiblePair() { return __and_, is_constructible<_T2, _U2&&>>::value; } template static constexpr bool _ImplicitlyMoveConvertiblePair() { return __and_, is_convertible<_U2&&, _T2>>::value; } }; template struct _PCC { template static constexpr bool _ConstructiblePair() { return false; } template static constexpr bool _ImplicitlyConvertiblePair() { return false; } template static constexpr bool _MoveConstructiblePair() { return false; } template static constexpr bool _ImplicitlyMoveConvertiblePair() { return false; } }; # 278 "/usr/include/c++/15/bits/stl_pair.h" 3 template class __pair_base { template friend struct pair; __pair_base() = default; ~__pair_base() = default; __pair_base(const __pair_base&) = default; __pair_base& operator=(const __pair_base&) = delete; }; # 301 "/usr/include/c++/15/bits/stl_pair.h" 3 template struct pair : public __pair_base<_T1, _T2> { typedef _T1 first_type; typedef _T2 second_type; _T1 first; _T2 second; constexpr pair(const pair&) = default; constexpr pair(pair&&) = default; template pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); void swap(pair& __p) noexcept(__and_<__is_nothrow_swappable<_T1>, __is_nothrow_swappable<_T2>>::value) { using std::swap; swap(first, __p.first); swap(second, __p.second); } # 349 "/usr/include/c++/15/bits/stl_pair.h" 3 private: template pair(tuple<_Args1...>&, tuple<_Args2...>&, _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); public: # 739 "/usr/include/c++/15/bits/stl_pair.h" 3 template , __is_implicitly_default_constructible<_U2>> ::value, bool>::type = true> constexpr pair() : first(), second() { } template , is_default_constructible<_U2>, __not_< __and_<__is_implicitly_default_constructible<_U1>, __is_implicitly_default_constructible<_U2>>>> ::value, bool>::type = false> explicit constexpr pair() : first(), second() { } using _PCCP = _PCC; template() && _PCCP::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) { } template() && !_PCCP::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) { } template using _PCCFP = _PCC::value || !is_same<_T2, _U2>::value, _T1, _T2>; template::template _ConstructiblePair<_U1, _U2>() && _PCCFP<_U1, _U2>::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) { ; } template::template _ConstructiblePair<_U1, _U2>() && !_PCCFP<_U1, _U2>::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) { ; } # 823 "/usr/include/c++/15/bits/stl_pair.h" 3 private: struct __zero_as_null_pointer_constant { __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) { } template::value>> __zero_as_null_pointer_constant(_Tp) = delete; }; public: template>, is_pointer<_T2>, is_constructible<_T1, _U1>, __not_>, is_convertible<_U1, _T1>>::value, bool> = true> __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) constexpr pair(_U1&& __x, __zero_as_null_pointer_constant, ...) : first(std::forward<_U1>(__x)), second(nullptr) { ; } template>, is_pointer<_T2>, is_constructible<_T1, _U1>, __not_>, __not_>>::value, bool> = false> __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) explicit constexpr pair(_U1&& __x, __zero_as_null_pointer_constant, ...) : first(std::forward<_U1>(__x)), second(nullptr) { ; } template, __not_>, is_constructible<_T2, _U2>, __not_>, is_convertible<_U2, _T2>>::value, bool> = true> __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) constexpr pair(__zero_as_null_pointer_constant, _U2&& __y, ...) : first(nullptr), second(std::forward<_U2>(__y)) { ; } template, __not_>, is_constructible<_T2, _U2>, __not_>, __not_>>::value, bool> = false> __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) explicit constexpr pair(__zero_as_null_pointer_constant, _U2&& __y, ...) : first(nullptr), second(std::forward<_U2>(__y)) { ; } template() && _PCCP::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(_U1&& __x, _U2&& __y) : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { ; } template() && !_PCCP::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(_U1&& __x, _U2&& __y) : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { ; } template::template _MoveConstructiblePair<_U1, _U2>() && _PCCFP<_U1, _U2>::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(pair<_U1, _U2>&& __p) : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) { ; } template::template _MoveConstructiblePair<_U1, _U2>() && !_PCCFP<_U1, _U2>::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(pair<_U1, _U2>&& __p) : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) { ; } pair& operator=(__conditional_t<__and_, is_copy_assignable<_T2>>::value, const pair&, const __nonesuch&> __p) { first = __p.first; second = __p.second; return *this; } pair& operator=(__conditional_t<__and_, is_move_assignable<_T2>>::value, pair&&, __nonesuch&&> __p) noexcept(__and_, is_nothrow_move_assignable<_T2>>::value) { first = std::forward(__p.first); second = std::forward(__p.second); return *this; } template typename enable_if<__and_, is_assignable<_T2&, const _U2&>>::value, pair&>::type operator=(const pair<_U1, _U2>& __p) { first = __p.first; second = __p.second; return *this; } template typename enable_if<__and_, is_assignable<_T2&, _U2&&>>::value, pair&>::type operator=(pair<_U1, _U2>&& __p) { first = std::forward<_U1>(__p.first); second = std::forward<_U2>(__p.second); return *this; } # 1015 "/usr/include/c++/15/bits/stl_pair.h" 3 }; template pair(_T1, _T2) -> pair<_T1, _T2>; # 1057 "/usr/include/c++/15/bits/stl_pair.h" 3 template [[__nodiscard__]] inline constexpr bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __x.first == __y.first && __x.second == __y.second; } # 1070 "/usr/include/c++/15/bits/stl_pair.h" 3 template [[__nodiscard__]] inline constexpr bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second); } template [[__nodiscard__]] inline constexpr bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__x == __y); } template [[__nodiscard__]] inline constexpr bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __y < __x; } template [[__nodiscard__]] inline constexpr bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline constexpr bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__x < __y); } # 1112 "/usr/include/c++/15/bits/stl_pair.h" 3 template inline typename enable_if<__and_<__is_swappable<_T1>, __is_swappable<_T2>>::value>::type swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } # 1135 "/usr/include/c++/15/bits/stl_pair.h" 3 template typename enable_if, __is_swappable<_T2>>::value>::type swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; # 1161 "/usr/include/c++/15/bits/stl_pair.h" 3 template constexpr pair::__type, typename __decay_and_strip<_T2>::__type> make_pair(_T1&& __x, _T2&& __y) { typedef typename __decay_and_strip<_T1>::__type __ds_type1; typedef typename __decay_and_strip<_T2>::__type __ds_type2; typedef pair<__ds_type1, __ds_type2> __pair_type; return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); } # 1184 "/usr/include/c++/15/bits/stl_pair.h" 3 template struct __is_tuple_like_impl> : true_type { }; template struct tuple_size> : public integral_constant { }; template struct tuple_element<0, pair<_Tp1, _Tp2>> { typedef _Tp1 type; }; template struct tuple_element<1, pair<_Tp1, _Tp2>> { typedef _Tp2 type; }; template inline constexpr size_t tuple_size_v> = 2; template inline constexpr size_t tuple_size_v> = 2; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++14-extensions" #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline constexpr bool __is_pair = false; template inline constexpr bool __is_pair> = true; #pragma GCC diagnostic pop template struct __pair_get; template<> struct __pair_get<0> { template static constexpr _Tp1& __get(pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.first; } template static constexpr _Tp1&& __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward<_Tp1>(__pair.first); } template static constexpr const _Tp1& __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.first; } template static constexpr const _Tp1&& __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward(__pair.first); } }; template<> struct __pair_get<1> { template static constexpr _Tp2& __get(pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.second; } template static constexpr _Tp2&& __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward<_Tp2>(__pair.second); } template static constexpr const _Tp2& __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.second; } template static constexpr const _Tp2&& __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward(__pair.second); } }; template constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& get(pair<_Tp1, _Tp2>& __in) noexcept { return __pair_get<_Int>::__get(__in); } template constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& get(pair<_Tp1, _Tp2>&& __in) noexcept { return __pair_get<_Int>::__move_get(std::move(__in)); } template constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& get(const pair<_Tp1, _Tp2>& __in) noexcept { return __pair_get<_Int>::__const_get(__in); } template constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& get(const pair<_Tp1, _Tp2>&& __in) noexcept { return __pair_get<_Int>::__const_move_get(std::move(__in)); } template constexpr _Tp& get(pair<_Tp, _Up>& __p) noexcept { return __p.first; } template constexpr const _Tp& get(const pair<_Tp, _Up>& __p) noexcept { return __p.first; } template constexpr _Tp&& get(pair<_Tp, _Up>&& __p) noexcept { return std::forward<_Tp>(__p.first); } template constexpr const _Tp&& get(const pair<_Tp, _Up>&& __p) noexcept { return std::forward(__p.first); } template constexpr _Tp& get(pair<_Up, _Tp>& __p) noexcept { return __p.second; } template constexpr const _Tp& get(const pair<_Up, _Tp>& __p) noexcept { return __p.second; } template constexpr _Tp&& get(pair<_Up, _Tp>&& __p) noexcept { return std::forward<_Tp>(__p.second); } template constexpr const _Tp&& get(const pair<_Up, _Tp>&& __p) noexcept { return std::forward(__p.second); } # 1365 "/usr/include/c++/15/bits/stl_pair.h" 3 } # 41 "/usr/include/c++/15/tuple" 2 3 # 1 "/usr/include/c++/15/bits/uses_allocator.h" 1 3 # 40 "/usr/include/c++/15/bits/uses_allocator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __erased_type { }; template using __is_erased_or_convertible = __or_, is_same<_Tp, __erased_type>>; struct allocator_arg_t { explicit allocator_arg_t() = default; }; inline constexpr allocator_arg_t allocator_arg = allocator_arg_t(); template> struct __uses_allocator_helper : false_type { }; template struct __uses_allocator_helper<_Tp, _Alloc, __void_t> : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type { }; template struct uses_allocator : __uses_allocator_helper<_Tp, _Alloc>::type { }; struct __uses_alloc_base { }; struct __uses_alloc0 : __uses_alloc_base { struct _Sink { void operator=(const void*) { } } _M_a; }; template struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; template struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; template struct __uses_alloc; template struct __uses_alloc : __conditional_t< is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, __uses_alloc1<_Alloc>, __uses_alloc2<_Alloc>> { static_assert(__or_< is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, is_constructible<_Tp, _Args..., const _Alloc&>>::value, "construction with an allocator must be possible" " if uses_allocator is true"); }; template struct __uses_alloc : __uses_alloc0 { }; template using __uses_alloc_t = __uses_alloc::value, _Tp, _Alloc, _Args...>; template inline __uses_alloc_t<_Tp, _Alloc, _Args...> __use_alloc(const _Alloc& __a) { __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; __ret._M_a = std::__addressof(__a); return __ret; } template void __use_alloc(const _Alloc&&) = delete; template inline constexpr bool uses_allocator_v = uses_allocator<_Tp, _Alloc>::value; template class _Predicate, typename _Tp, typename _Alloc, typename... _Args> struct __is_uses_allocator_predicate : __conditional_t::value, __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, _Predicate<_Tp, _Args..., _Alloc>>, _Predicate<_Tp, _Args...>> { }; template struct __is_uses_allocator_constructible : __is_uses_allocator_predicate { }; template inline constexpr bool __is_uses_allocator_constructible_v = __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; template struct __is_nothrow_uses_allocator_constructible : __is_uses_allocator_predicate { }; template inline constexpr bool __is_nothrow_uses_allocator_constructible_v = __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; template void __uses_allocator_construct_impl(__uses_alloc0, _Tp* __ptr, _Args&&... __args) { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } template void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, _Args&&... __args) { ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, std::forward<_Args>(__args)...); } template void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, _Args&&... __args) { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } template void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, _Args&&... __args) { std::__uses_allocator_construct_impl( std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, std::forward<_Args>(__args)...); } } # 42 "/usr/include/c++/15/tuple" 2 3 # 1 "/usr/include/c++/15/bits/invoke.h" 1 3 # 44 "/usr/include/c++/15/bits/invoke.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 55 "/usr/include/c++/15/bits/invoke.h" 3 template::type> constexpr _Up&& __invfwd(typename remove_reference<_Tp>::type& __t) noexcept { return static_cast<_Up&&>(__t); } template constexpr _Res __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } template constexpr _Res __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, _Args&&... __args) { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } template constexpr _Res __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, _Args&&... __args) { return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); } template constexpr _Res __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) { return __invfwd<_Tp>(__t).*__f; } template constexpr _Res __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) { return (*std::forward<_Tp>(__t)).*__f; } template constexpr typename __invoke_result<_Callable, _Args...>::type __invoke(_Callable&& __fn, _Args&&... __args) noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) { using __result = __invoke_result<_Callable, _Args...>; using __type = typename __result::type; using __tag = typename __result::__invoke_type; return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); } template constexpr enable_if_t, _Res> __invoke_r(_Callable&& __fn, _Args&&... __args) noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) { using __result = __invoke_result<_Callable, _Args...>; using __type = typename __result::type; using __tag = typename __result::__invoke_type; if constexpr (is_void_v<_Res>) std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); else return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); } # 157 "/usr/include/c++/15/bits/invoke.h" 3 } # 44 "/usr/include/c++/15/tuple" 2 3 # 57 "/usr/include/c++/15/tuple" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 58 "/usr/include/c++/15/tuple" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class tuple; template struct __is_empty_non_tuple : is_empty<_Tp> { }; template struct __is_empty_non_tuple> : false_type { }; template using __empty_not_final = __conditional_t<__is_final(_Tp), false_type, __is_empty_non_tuple<_Tp>>; template::value> struct _Head_base; template struct _Head_base<_Idx, _Head, true> { constexpr _Head_base() : _M_head_impl() { } constexpr _Head_base(const _Head& __h) : _M_head_impl(__h) { } constexpr _Head_base(const _Head_base&) = default; constexpr _Head_base(_Head_base&&) = default; template constexpr _Head_base(_UHead&& __h) : _M_head_impl(std::forward<_UHead>(__h)) { } _Head_base(allocator_arg_t, __uses_alloc0) : _M_head_impl() { } template _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) : _M_head_impl(allocator_arg, *__a._M_a) { } template _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) : _M_head_impl(*__a._M_a) { } template _Head_base(__uses_alloc0, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } static constexpr _Head& _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } static constexpr const _Head& _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } [[__no_unique_address__]] _Head _M_head_impl; }; # 199 "/usr/include/c++/15/tuple" 3 template struct _Head_base<_Idx, _Head, false> { constexpr _Head_base() : _M_head_impl() { } constexpr _Head_base(const _Head& __h) : _M_head_impl(__h) { } constexpr _Head_base(const _Head_base&) = default; constexpr _Head_base(_Head_base&&) = default; template constexpr _Head_base(_UHead&& __h) : _M_head_impl(std::forward<_UHead>(__h)) { } _Head_base(allocator_arg_t, __uses_alloc0) : _M_head_impl() { } template _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) : _M_head_impl(allocator_arg, *__a._M_a) { } template _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) : _M_head_impl(*__a._M_a) { } template _Head_base(__uses_alloc0, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } static constexpr _Head& _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } static constexpr const _Head& _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } _Head _M_head_impl; }; # 272 "/usr/include/c++/15/tuple" 3 template struct _Tuple_impl; template struct _Tuple_impl<_Idx, _Head, _Tail...> : public _Tuple_impl<_Idx + 1, _Tail...>, private _Head_base<_Idx, _Head> { template friend struct _Tuple_impl; typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; typedef _Head_base<_Idx, _Head> _Base; static constexpr _Head& _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr const _Head& _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr _Inherited& _M_tail(_Tuple_impl& __t) noexcept { return __t; } static constexpr const _Inherited& _M_tail(const _Tuple_impl& __t) noexcept { return __t; } constexpr _Tuple_impl() : _Inherited(), _Base() { } explicit constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) : _Inherited(__tail...), _Base(__head) { } template> explicit constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) : _Inherited(std::forward<_UTail>(__tail)...), _Base(std::forward<_UHead>(__head)) { } constexpr _Tuple_impl(const _Tuple_impl&) = default; _Tuple_impl& operator=(const _Tuple_impl&) = delete; _Tuple_impl(_Tuple_impl&&) = default; template constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } template constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) : _Inherited(std::move (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), _Base(std::forward<_UHead> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } # 368 "/usr/include/c++/15/tuple" 3 template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a), _Base(__tag, __use_alloc<_Head>(__a)) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Head& __head, const _Tail&... __tail) : _Inherited(__tag, __a, __tail...), _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } template> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _UHead&& __head, _UTail&&... __tail) : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead>(__head)) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl& __in) : _Inherited(__tag, __a, _M_tail(__in)), _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl&& __in) : _Inherited(__tag, __a, std::move(_M_tail(__in))), _Base(__use_alloc<_Head, _Alloc, _Head>(__a), std::forward<_Head>(_M_head(__in))) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) : _Inherited(__tag, __a, _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) : _Inherited(__tag, __a, std::move (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } # 463 "/usr/include/c++/15/tuple" 3 template void _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) { _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); _M_tail(*this)._M_assign( _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); } template void _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) { _M_head(*this) = std::forward<_UHead> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); _M_tail(*this)._M_assign( std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); } # 523 "/usr/include/c++/15/tuple" 3 protected: void _M_swap(_Tuple_impl& __in) { using std::swap; swap(_M_head(*this), _M_head(__in)); _Inherited::_M_swap(_M_tail(__in)); } # 542 "/usr/include/c++/15/tuple" 3 }; template struct _Tuple_impl<_Idx, _Head> : private _Head_base<_Idx, _Head> { template friend struct _Tuple_impl; typedef _Head_base<_Idx, _Head> _Base; static constexpr _Head& _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr const _Head& _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } constexpr _Tuple_impl() : _Base() { } explicit constexpr _Tuple_impl(const _Head& __head) : _Base(__head) { } template explicit constexpr _Tuple_impl(_UHead&& __head) : _Base(std::forward<_UHead>(__head)) { } constexpr _Tuple_impl(const _Tuple_impl&) = default; _Tuple_impl& operator=(const _Tuple_impl&) = delete; constexpr _Tuple_impl(_Tuple_impl&& __in) noexcept(is_nothrow_move_constructible<_Head>::value) : _Base(static_cast<_Base&&>(__in)) { } template constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } template constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) { } # 624 "/usr/include/c++/15/tuple" 3 template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) : _Base(__tag, __use_alloc<_Head>(__a)) { } template _Tuple_impl(allocator_arg_t, const _Alloc& __a, const _Head& __head) : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) { } template _Tuple_impl(allocator_arg_t, const _Alloc& __a, _UHead&& __head) : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead>(__head)) { } template _Tuple_impl(allocator_arg_t, const _Alloc& __a, const _Tuple_impl& __in) : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) { } template _Tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple_impl&& __in) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), std::forward<_Head>(_M_head(__in))) { } template _Tuple_impl(allocator_arg_t, const _Alloc& __a, const _Tuple_impl<_Idx, _UHead>& __in) : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } template _Tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple_impl<_Idx, _UHead>&& __in) : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) { } # 703 "/usr/include/c++/15/tuple" 3 template void _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) { _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); } template void _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) { _M_head(*this) = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); } # 749 "/usr/include/c++/15/tuple" 3 protected: void _M_swap(_Tuple_impl& __in) { using std::swap; swap(_M_head(*this), _M_head(__in)); } # 766 "/usr/include/c++/15/tuple" 3 }; template struct _TupleConstraints { template using __constructible = __and_...>; template using __convertible = __and_...>; template static constexpr bool __is_implicitly_constructible() { return __and_<__constructible<_UTypes...>, __convertible<_UTypes...> >::value; } template static constexpr bool __is_explicitly_constructible() { return __and_<__constructible<_UTypes...>, __not_<__convertible<_UTypes...>> >::value; } static constexpr bool __is_implicitly_default_constructible() { return __and_... >::value; } static constexpr bool __is_explicitly_default_constructible() { return __and_..., __not_<__and_< std::__is_implicitly_default_constructible<_Types>...> >>::value; } }; template struct _TupleConstraints { template static constexpr bool __is_implicitly_constructible() { return false; } template static constexpr bool __is_explicitly_constructible() { return false; } }; template class tuple : public _Tuple_impl<0, _Elements...> { using _Inherited = _Tuple_impl<0, _Elements...>; # 1352 "/usr/include/c++/15/tuple" 3 template using _TCC = _TupleConstraints<_Cond, _Elements...>; template using _ImplicitDefaultCtor = __enable_if_t< _TCC<_Dummy>::__is_implicitly_default_constructible(), bool>; template using _ExplicitDefaultCtor = __enable_if_t< _TCC<_Dummy>::__is_explicitly_default_constructible(), bool>; template using _ImplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), bool>; template using _ExplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), bool>; template static constexpr bool __nothrow_constructible() { return __and_...>::value; } template static constexpr bool __valid_args() { return sizeof...(_Elements) == 1 && !is_same>::value; } template static constexpr bool __valid_args() { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } # 1409 "/usr/include/c++/15/tuple" 3 template> struct _UseOtherCtor : false_type { }; template struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> : __or_, is_constructible<_Tp, _Tuple>>::type { }; template struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> : true_type { }; template static constexpr bool __use_other_ctor() { return _UseOtherCtor<_Tuple>::value; } # 1455 "/usr/include/c++/15/tuple" 3 public: template::value> = true> constexpr tuple() noexcept(__and_...>::value) : _Inherited() { } template::value> = false> explicit constexpr tuple() noexcept(__and_...>::value) : _Inherited() { } template= 1), _ImplicitCtor<_NotEmpty, const _Elements&...> = true> constexpr tuple(const _Elements&... __elements) noexcept(__nothrow_constructible()) : _Inherited(__elements...) { } template= 1), _ExplicitCtor<_NotEmpty, const _Elements&...> = false> explicit constexpr tuple(const _Elements&... __elements) noexcept(__nothrow_constructible()) : _Inherited(__elements...) { } template(), _ImplicitCtor<_Valid, _UElements...> = true> constexpr tuple(_UElements&&... __elements) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(std::forward<_UElements>(__elements)...) { ; } template(), _ExplicitCtor<_Valid, _UElements...> = false> explicit constexpr tuple(_UElements&&... __elements) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(std::forward<_UElements>(__elements)...) { ; } constexpr tuple(const tuple&) = default; constexpr tuple(tuple&&) = default; template&>(), _ImplicitCtor<_Valid, const _UElements&...> = true> constexpr tuple(const tuple<_UElements...>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { ; } template&>(), _ExplicitCtor<_Valid, const _UElements&...> = false> explicit constexpr tuple(const tuple<_UElements...>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { ; } template&&>(), _ImplicitCtor<_Valid, _UElements...> = true> constexpr tuple(tuple<_UElements...>&& __in) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { ; } template&&>(), _ExplicitCtor<_Valid, _UElements...> = false> explicit constexpr tuple(tuple<_UElements...>&& __in) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { ; } template::value> = true> tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template::value> = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template= 1), _ImplicitCtor<_NotEmpty, const _Elements&...> = true> tuple(allocator_arg_t __tag, const _Alloc& __a, const _Elements&... __elements) : _Inherited(__tag, __a, __elements...) { } template= 1), _ExplicitCtor<_NotEmpty, const _Elements&...> = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const _Elements&... __elements) : _Inherited(__tag, __a, __elements...) { } template(), _ImplicitCtor<_Valid, _UElements...> = true> tuple(allocator_arg_t __tag, const _Alloc& __a, _UElements&&... __elements) : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) { ; } template(), _ExplicitCtor<_Valid, _UElements...> = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, _UElements&&... __elements) : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) { ; } template tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) : _Inherited(__tag, __a, static_cast(__in)) { } template tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } template&>(), _ImplicitCtor<_Valid, const _UElements&...> = true> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_UElements...>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { ; } template&>(), _ExplicitCtor<_Valid, const _UElements&...> = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_UElements...>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { ; } template&&>(), _ImplicitCtor<_Valid, _UElements...> = true> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UElements...>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { ; } template&&>(), _ExplicitCtor<_Valid, _UElements...> = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UElements...>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { ; } # 1887 "/usr/include/c++/15/tuple" 3 private: template static constexpr __enable_if_t __assignable() { return __and_...>::value; } template static constexpr bool __nothrow_assignable() { return __and_...>::value; } public: tuple& operator=(__conditional_t<__assignable(), const tuple&, const __nonesuch&> __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } tuple& operator=(__conditional_t<__assignable<_Elements...>(), tuple&&, __nonesuch&&> __in) noexcept(__nothrow_assignable<_Elements...>()) { this->_M_assign(std::move(__in)); return *this; } template __enable_if_t<__assignable(), tuple&> operator=(const tuple<_UElements...>& __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } template __enable_if_t<__assignable<_UElements...>(), tuple&> operator=(tuple<_UElements...>&& __in) noexcept(__nothrow_assignable<_UElements...>()) { this->_M_assign(std::move(__in)); return *this; } void swap(tuple& __in) noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) { _Inherited::_M_swap(__in); } # 1967 "/usr/include/c++/15/tuple" 3 }; template tuple(_UTypes...) -> tuple<_UTypes...>; template tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; template tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; template tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; template tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; template<> class tuple<> { public: void swap(tuple&) noexcept { } tuple() = default; template tuple(allocator_arg_t, const _Alloc&) noexcept { } template tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } }; template class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> { typedef _Tuple_impl<0, _T1, _T2> _Inherited; template using _ImplicitDefaultCtor = __enable_if_t< _TupleConstraints<_Dummy, _U1, _U2>:: __is_implicitly_default_constructible(), bool>; template using _ExplicitDefaultCtor = __enable_if_t< _TupleConstraints<_Dummy, _U1, _U2>:: __is_explicitly_default_constructible(), bool>; template using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; template using _ImplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), bool>; template using _ExplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), bool>; template static constexpr bool __assignable() { return __and_, is_assignable<_T2&, _U2>>::value; } template static constexpr bool __nothrow_assignable() { return __and_, is_nothrow_assignable<_T2&, _U2>>::value; } template static constexpr bool __nothrow_constructible() { return __and_, is_nothrow_constructible<_T2, _U2>>::value; } static constexpr bool __nothrow_default_constructible() { return __and_, is_nothrow_default_constructible<_T2>>::value; } template static constexpr bool __is_alloc_arg() { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } # 2086 "/usr/include/c++/15/tuple" 3 public: template = true> constexpr tuple() noexcept(__nothrow_default_constructible()) : _Inherited() { } template = false> explicit constexpr tuple() noexcept(__nothrow_default_constructible()) : _Inherited() { } template = true> constexpr tuple(const _T1& __a1, const _T2& __a2) noexcept(__nothrow_constructible()) : _Inherited(__a1, __a2) { } template = false> explicit constexpr tuple(const _T1& __a1, const _T2& __a2) noexcept(__nothrow_constructible()) : _Inherited(__a1, __a2) { } template(), _U1, _U2> = true> constexpr tuple(_U1&& __a1, _U2&& __a2) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { ; } template(), _U1, _U2> = false> explicit constexpr tuple(_U1&& __a1, _U2&& __a2) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { ; } constexpr tuple(const tuple&) = default; constexpr tuple(tuple&&) = default; template = true> constexpr tuple(const tuple<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { ; } template = false> explicit constexpr tuple(const tuple<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { ; } template = true> constexpr tuple(tuple<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { ; } template = false> explicit constexpr tuple(tuple<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { ; } template = true> constexpr tuple(const pair<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(__in.first, __in.second) { ; } template = false> explicit constexpr tuple(const pair<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(__in.first, __in.second) { ; } template = true> constexpr tuple(pair<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { ; } template = false> explicit constexpr tuple(pair<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { ; } template::value, _T1, _T2> = true> tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template::value, _T1, _T2> = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template = true> tuple(allocator_arg_t __tag, const _Alloc& __a, const _T1& __a1, const _T2& __a2) : _Inherited(__tag, __a, __a1, __a2) { } template = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const _T1& __a1, const _T2& __a2) : _Inherited(__tag, __a, __a1, __a2) { } template = true> tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) : _Inherited(__tag, __a, std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { ; } template = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) : _Inherited(__tag, __a, std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { ; } template tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) : _Inherited(__tag, __a, static_cast(__in)) { } template tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } template = true> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_U1, _U2>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { ; } template = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_U1, _U2>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { ; } template = true> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { ; } template = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { ; } template = true> tuple(allocator_arg_t __tag, const _Alloc& __a, const pair<_U1, _U2>& __in) : _Inherited(__tag, __a, __in.first, __in.second) { ; } template = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const pair<_U1, _U2>& __in) : _Inherited(__tag, __a, __in.first, __in.second) { ; } template = true> tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) : _Inherited(__tag, __a, std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { ; } template = false> explicit tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) : _Inherited(__tag, __a, std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { ; } tuple& operator=(__conditional_t<__assignable(), const tuple&, const __nonesuch&> __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } tuple& operator=(__conditional_t<__assignable<_T1, _T2>(), tuple&&, __nonesuch&&> __in) noexcept(__nothrow_assignable<_T1, _T2>()) { this->_M_assign(std::move(__in)); return *this; } template __enable_if_t<__assignable(), tuple&> operator=(const tuple<_U1, _U2>& __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } template __enable_if_t<__assignable<_U1, _U2>(), tuple&> operator=(tuple<_U1, _U2>&& __in) noexcept(__nothrow_assignable<_U1, _U2>()) { this->_M_assign(std::move(__in)); return *this; } template __enable_if_t<__assignable(), tuple&> operator=(const pair<_U1, _U2>& __in) noexcept(__nothrow_assignable()) { this->_M_head(*this) = __in.first; this->_M_tail(*this)._M_head(*this) = __in.second; return *this; } template __enable_if_t<__assignable<_U1, _U2>(), tuple&> operator=(pair<_U1, _U2>&& __in) noexcept(__nothrow_assignable<_U1, _U2>()) { this->_M_head(*this) = std::forward<_U1>(__in.first); this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); return *this; } void swap(tuple& __in) noexcept(__and_<__is_nothrow_swappable<_T1>, __is_nothrow_swappable<_T2>>::value) { _Inherited::_M_swap(__in); } }; template struct tuple_size> : public integral_constant { }; template inline constexpr size_t tuple_size_v> = sizeof...(_Types); template inline constexpr size_t tuple_size_v> = sizeof...(_Types); template struct tuple_element<__i, tuple<_Types...>> { static_assert(__i < sizeof...(_Types), "tuple index must be in range"); using type = typename _Nth_type<__i, _Types...>::type; }; template constexpr _Head& __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } template constexpr const _Head& __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } template __enable_if_t<(__i >= sizeof...(_Types))> __get_helper(const tuple<_Types...>&) = delete; template constexpr __tuple_element_t<__i, tuple<_Elements...>>& get(tuple<_Elements...>& __t) noexcept { return std::__get_helper<__i>(__t); } template constexpr const __tuple_element_t<__i, tuple<_Elements...>>& get(const tuple<_Elements...>& __t) noexcept { return std::__get_helper<__i>(__t); } template constexpr __tuple_element_t<__i, tuple<_Elements...>>&& get(tuple<_Elements...>&& __t) noexcept { typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; return std::forward<__element_type>(std::__get_helper<__i>(__t)); } template constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& get(const tuple<_Elements...>&& __t) noexcept { typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; return std::forward(std::__get_helper<__i>(__t)); } template constexpr __enable_if_t<(__i >= sizeof...(_Elements))> get(const tuple<_Elements...>&) = delete; template constexpr _Tp& get(tuple<_Types...>& __t) noexcept { constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); static_assert(__idx < sizeof...(_Types), "the type T in std::get must occur exactly once in the tuple"); return std::__get_helper<__idx>(__t); } template constexpr _Tp&& get(tuple<_Types...>&& __t) noexcept { constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); static_assert(__idx < sizeof...(_Types), "the type T in std::get must occur exactly once in the tuple"); return std::forward<_Tp>(std::__get_helper<__idx>(__t)); } template constexpr const _Tp& get(const tuple<_Types...>& __t) noexcept { constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); static_assert(__idx < sizeof...(_Types), "the type T in std::get must occur exactly once in the tuple"); return std::__get_helper<__idx>(__t); } template constexpr const _Tp&& get(const tuple<_Types...>&& __t) noexcept { constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); static_assert(__idx < sizeof...(_Types), "the type T in std::get must occur exactly once in the tuple"); return std::forward(std::__get_helper<__idx>(__t)); } # 2578 "/usr/include/c++/15/tuple" 3 template struct __tuple_compare { static constexpr bool __eq(const _Tp& __t, const _Up& __u) { return bool(std::get<__i>(__t) == std::get<__i>(__u)) && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); } static constexpr bool __less(const _Tp& __t, const _Up& __u) { return bool(std::get<__i>(__t) < std::get<__i>(__u)) || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); } }; template struct __tuple_compare<_Tp, _Up, __size, __size> { static constexpr bool __eq(const _Tp&, const _Up&) { return true; } static constexpr bool __less(const _Tp&, const _Up&) { return false; } }; template [[__nodiscard__]] constexpr bool operator==(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { static_assert(sizeof...(_TElements) == sizeof...(_UElements), "tuple objects can only be compared if they have equal sizes."); using __compare = __tuple_compare, tuple<_UElements...>, 0, sizeof...(_TElements)>; return __compare::__eq(__t, __u); } template [[__nodiscard__]] constexpr bool operator<(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { static_assert(sizeof...(_TElements) == sizeof...(_UElements), "tuple objects can only be compared if they have equal sizes."); using __compare = __tuple_compare, tuple<_UElements...>, 0, sizeof...(_TElements)>; return __compare::__less(__t, __u); } template [[__nodiscard__]] constexpr bool operator!=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return !(__t == __u); } template [[__nodiscard__]] constexpr bool operator>(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return __u < __t; } template [[__nodiscard__]] constexpr bool operator<=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return !(__u < __t); } template [[__nodiscard__]] constexpr bool operator>=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return !(__t < __u); } template constexpr tuple::__type...> make_tuple(_Elements&&... __args) { typedef tuple::__type...> __result_type; return __result_type(std::forward<_Elements>(__args)...); } template constexpr tuple<_Elements&&...> forward_as_tuple(_Elements&&... __args) noexcept { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } template struct __make_tuple_impl; template struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> : __make_tuple_impl<_Idx + 1, tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, _Tuple, _Nm> { }; template struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> { typedef tuple<_Tp...> __type; }; template struct __do_make_tuple : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> { }; template struct __make_tuple : public __do_make_tuple<__remove_cvref_t<_Tuple>> { }; template struct __combine_tuples; template<> struct __combine_tuples<> { typedef tuple<> __type; }; template struct __combine_tuples> { typedef tuple<_Ts...> __type; }; template struct __combine_tuples, tuple<_T2s...>, _Rem...> { typedef typename __combine_tuples, _Rem...>::__type __type; }; template struct __tuple_cat_result { typedef typename __combine_tuples ::__type...>::__type __type; }; template struct __make_1st_indices; template<> struct __make_1st_indices<> { typedef _Index_tuple<> __type; }; template struct __make_1st_indices<_Tp, _Tpls...> { typedef typename _Build_index_tuple::type>::value>::__type __type; }; template struct __tuple_concater; template struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> { template static constexpr _Ret _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) { typedef typename __make_1st_indices<_Tpls...>::__type __idx; typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; return __next::_S_do(std::forward<_Tpls>(__tps)..., std::forward<_Us>(__us)..., std::get<_Is>(std::forward<_Tp>(__tp))...); } }; template struct __tuple_concater<_Ret, _Index_tuple<>> { template static constexpr _Ret _S_do(_Us&&... __us) { return _Ret(std::forward<_Us>(__us)...); } }; template struct __is_tuple_like_impl> : true_type { }; template...>::value>::type> constexpr auto tuple_cat(_Tpls&&... __tpls) -> typename __tuple_cat_result<_Tpls...>::__type { typedef typename __tuple_cat_result<_Tpls...>::__type __ret; typedef typename __make_1st_indices<_Tpls...>::__type __idx; typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; return __concater::_S_do(std::forward<_Tpls>(__tpls)...); } template constexpr tuple<_Elements&...> tie(_Elements&... __args) noexcept { return tuple<_Elements&...>(__args...); } template inline typename enable_if<__and_<__is_swappable<_Elements>...>::value >::type swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } # 2848 "/usr/include/c++/15/tuple" 3 template typename enable_if...>::value>::type swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; template struct uses_allocator, _Alloc> : true_type { }; # 2867 "/usr/include/c++/15/tuple" 3 template template inline pair<_T1, _T2>:: pair(piecewise_construct_t, tuple<_Args1...> __first, tuple<_Args2...> __second) : pair(__first, __second, typename _Build_index_tuple::__type(), typename _Build_index_tuple::__type()) { } template template inline pair<_T1, _T2>:: pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) { } template class _Trait, typename _Tp, typename _Tuple> inline constexpr bool __unpack_std_tuple = false; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> = _Trait<_Tp, _Up...>::value; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> = _Trait<_Tp, _Up&...>::value; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> = _Trait<_Tp, const _Up...>::value; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> = _Trait<_Tp, const _Up&...>::value; template constexpr decltype(auto) __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) { return std::__invoke(std::forward<_Fn>(__f), std::get<_Idx>(std::forward<_Tuple>(__t))...); } template constexpr decltype(auto) apply(_Fn&& __f, _Tuple&& __t) noexcept(__unpack_std_tuple) { using _Indices = make_index_sequence>>; return std::__apply_impl(std::forward<_Fn>(__f), std::forward<_Tuple>(__t), _Indices{}); } template constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } template constexpr _Tp make_from_tuple(_Tuple&& __t) noexcept(__unpack_std_tuple) { constexpr size_t __n = tuple_size_v>; if constexpr (__n == 1) { using _Elt = decltype(std::get<0>(std::declval<_Tuple>())); static_assert(!__reference_constructs_from_temporary(_Tp, _Elt)); } return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), make_index_sequence<__n>{}); } # 3029 "/usr/include/c++/15/tuple" 3 } # 56 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/bits/functional_hash.h" 1 3 # 38 "/usr/include/c++/15/bits/functional_hash.h" 3 # 1 "/usr/include/c++/15/bits/hash_bytes.h" 1 3 # 39 "/usr/include/c++/15/bits/hash_bytes.h" 3 namespace std { size_t _Hash_bytes(const void* __ptr, size_t __len, size_t __seed); size_t _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed); } # 39 "/usr/include/c++/15/bits/functional_hash.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 52 "/usr/include/c++/15/bits/functional_hash.h" 3 template struct __hash_base { typedef _Result result_type [[__deprecated__]]; typedef _Arg argument_type [[__deprecated__]]; }; template struct __hash_empty_base { }; template struct hash; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++14-extensions" template constexpr bool __is_hash_enabled_for = false; template constexpr bool __is_hash_enabled_for<_Tp, __void_t()(declval<_Tp>()))>> = true; #pragma GCC diagnostic pop template struct __hash_not_enabled { __hash_not_enabled(__hash_not_enabled&&) = delete; ~__hash_not_enabled() = delete; }; template struct __hash_enum : public __hash_base { size_t operator()(_Tp __val) const noexcept { using __type = typename underlying_type<_Tp>::type; return hash<__type>{}(static_cast<__type>(__val)); } }; template struct hash : __conditional_t<__is_enum(_Tp), __hash_enum<_Tp>, __hash_not_enabled<_Tp>> { }; template struct hash<_Tp*> : public __hash_base { size_t operator()(_Tp* __p) const noexcept { return reinterpret_cast(__p); } }; # 128 "/usr/include/c++/15/bits/functional_hash.h" 3 template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; __extension__ template<> struct hash<__int128> : public __hash_base { size_t operator()(__int128 __val) const noexcept { return static_cast(__val); } }; __extension__ template<> struct hash<__int128 unsigned> : public __hash_base { size_t operator()(__int128 unsigned __val) const noexcept { return static_cast(__val); } }; # 204 "/usr/include/c++/15/bits/functional_hash.h" 3 struct _Hash_impl { static size_t hash(const void* __ptr, size_t __clength, size_t __seed = static_cast(0xc70f6907UL)) { return _Hash_bytes(__ptr, __clength, __seed); } template static size_t hash(const _Tp& __val) { return hash(&__val, sizeof(__val)); } template static size_t __hash_combine(const _Tp& __val, size_t __hash) { return hash(&__val, sizeof(__val), __hash); } }; struct _Fnv_hash_impl { static size_t hash(const void* __ptr, size_t __clength, size_t __seed = static_cast(2166136261UL)) { return _Fnv_hash_bytes(__ptr, __clength, __seed); } template static size_t hash(const _Tp& __val) { return hash(&__val, sizeof(__val)); } template static size_t __hash_combine(const _Tp& __val, size_t __hash) { return hash(&__val, sizeof(__val), __hash); } }; template<> struct hash : public __hash_base { size_t operator()(float __val) const noexcept { return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; } }; template<> struct hash : public __hash_base { size_t operator()(double __val) const noexcept { return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; } }; template<> struct hash : public __hash_base { __attribute__ ((__pure__)) size_t operator()(long double __val) const noexcept; }; template<> struct hash : public __hash_base { size_t operator()(nullptr_t) const noexcept { return 0; } }; # 297 "/usr/include/c++/15/bits/functional_hash.h" 3 template struct __is_fast_hash : public std::true_type { }; template<> struct __is_fast_hash> : public std::false_type { }; } # 58 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/bits/refwrap.h" 1 3 # 47 "/usr/include/c++/15/bits/refwrap.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 58 "/usr/include/c++/15/bits/refwrap.h" 3 template struct _Maybe_unary_or_binary_function { }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct _Maybe_unary_or_binary_function<_Res, _T1> : std::unary_function<_T1, _Res> { }; template struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> : std::binary_function<_T1, _T2, _Res> { }; #pragma GCC diagnostic pop template struct _Mem_fn_traits; template struct _Mem_fn_traits_base { using __result_type = _Res; using __maybe_type = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; using __arity = integral_constant; }; # 109 "/usr/include/c++/15/bits/refwrap.h" 3 template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes..., ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template> struct _Maybe_get_result_type { }; template struct _Maybe_get_result_type<_Functor, __void_t> { typedef typename _Functor::result_type result_type; }; template struct _Weak_result_type_impl : _Maybe_get_result_type<_Functor> { }; template struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> { typedef _Res result_type; }; template struct _Weak_result_type_impl<_Res(_ArgTypes..., ...) noexcept (_NE)> { typedef _Res result_type; }; template struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> { typedef _Res result_type; }; template struct _Weak_result_type_impl<_Res(*)(_ArgTypes..., ...) noexcept (_NE)> { typedef _Res result_type; }; template::value> struct _Weak_result_type_memfun : _Weak_result_type_impl<_Functor> { }; template struct _Weak_result_type_memfun<_MemFunPtr, true> { using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; }; template struct _Weak_result_type_memfun<_Func _Class::*, false> { }; template struct _Weak_result_type : _Weak_result_type_memfun::type> { }; template> struct _Refwrap_base_arg1 { }; template struct _Refwrap_base_arg1<_Tp, __void_t> { typedef typename _Tp::argument_type argument_type; }; template> struct _Refwrap_base_arg2 { }; template struct _Refwrap_base_arg2<_Tp, __void_t> { typedef typename _Tp::first_argument_type first_argument_type; typedef typename _Tp::second_argument_type second_argument_type; }; template struct _Reference_wrapper_base : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> { }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> : unary_function<_T1, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1) const> : unary_function<_T1, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1) volatile> : unary_function<_T1, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1) const volatile> : unary_function<_T1, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> : binary_function<_T1, _T2, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1, _T2) const> : binary_function<_T1, _T2, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> : binary_function<_T1, _T2, _Res> { }; template struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> : binary_function<_T1, _T2, _Res> { }; template struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> : unary_function<_T1, _Res> { }; template struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> : binary_function<_T1, _T2, _Res> { }; template::value> struct _Reference_wrapper_base_memfun : _Reference_wrapper_base<_Tp> { }; template struct _Reference_wrapper_base_memfun<_MemFunPtr, true> : _Mem_fn_traits<_MemFunPtr>::__maybe_type { using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; }; #pragma GCC diagnostic pop # 309 "/usr/include/c++/15/bits/refwrap.h" 3 template class reference_wrapper : public _Reference_wrapper_base_memfun::type> { _Tp* _M_data; static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } static void _S_fun(_Tp&&) = delete; template> using __not_same = typename enable_if::value>::type; public: typedef _Tp type; template, typename = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> reference_wrapper(_Up&& __uref) noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) { } reference_wrapper(const reference_wrapper&) = default; reference_wrapper& operator=(const reference_wrapper&) = default; operator _Tp&() const noexcept { return this->get(); } _Tp& get() const noexcept { return *_M_data; } template typename __invoke_result<_Tp&, _Args...>::type operator()(_Args&&... __args) const noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) { return std::__invoke(get(), std::forward<_Args>(__args)...); } # 415 "/usr/include/c++/15/bits/refwrap.h" 3 }; template reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; template inline reference_wrapper<_Tp> ref(_Tp& __t) noexcept { return reference_wrapper<_Tp>(__t); } template inline reference_wrapper cref(const _Tp& __t) noexcept { return reference_wrapper(__t); } template void ref(const _Tp&&) = delete; template void cref(const _Tp&&) = delete; template inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept { return __t; } template inline reference_wrapper cref(reference_wrapper<_Tp> __t) noexcept { return { __t.get() }; } } # 60 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/bits/std_function.h" 1 3 # 41 "/usr/include/c++/15/bits/std_function.h" 3 # 1 "/usr/include/c++/15/new" 1 3 # 43 "/usr/include/c++/15/new" 3 # 1 "/usr/include/c++/15/bits/exception.h" 1 3 # 40 "/usr/include/c++/15/bits/exception.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { # 61 "/usr/include/c++/15/bits/exception.h" 3 class exception { public: exception() noexcept { } virtual ~exception() noexcept; exception(const exception&) = default; exception& operator=(const exception&) = default; exception(exception&&) = default; exception& operator=(exception&&) = default; virtual const char* what() const noexcept; }; } } # 44 "/usr/include/c++/15/new" 2 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 50 "/usr/include/c++/15/new" 2 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" #pragma GCC visibility push(default) extern "C++" { namespace std { class bad_alloc : public exception { public: bad_alloc() throw() { } bad_alloc(const bad_alloc&) = default; bad_alloc& operator=(const bad_alloc&) = default; virtual ~bad_alloc() throw(); virtual const char* what() const throw(); }; class bad_array_new_length : public bad_alloc { public: bad_array_new_length() throw() { } virtual ~bad_array_new_length() throw(); virtual const char* what() const throw(); }; enum class align_val_t: size_t {}; struct nothrow_t { explicit nothrow_t() = default; }; extern const nothrow_t nothrow; typedef void (*new_handler)(); new_handler set_new_handler(new_handler) throw(); new_handler get_new_handler() noexcept; } # 137 "/usr/include/c++/15/new" 3 [[__nodiscard__]] void* operator new(std::size_t) __attribute__((__externally_visible__, __malloc__)); [[__nodiscard__]] void* operator new[](std::size_t) __attribute__((__externally_visible__, __malloc__)); void operator delete(void*) noexcept __attribute__((__externally_visible__)); void operator delete[](void*) noexcept __attribute__((__externally_visible__)); void operator delete(void*, std::size_t) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, std::size_t) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); [[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); void operator delete(void*, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__)); [[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__)); void operator delete(void*, std::align_val_t) noexcept __attribute__((__externally_visible__)); void operator delete(void*, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__)); [[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__)); void operator delete[](void*, std::align_val_t) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); void operator delete(void*, std::size_t, std::align_val_t) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, std::size_t, std::align_val_t) noexcept __attribute__((__externally_visible__)); # 205 "/usr/include/c++/15/new" 3 [[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept { return __p; } [[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept { return __p; } inline void operator delete (void*, void*) noexcept { } inline void operator delete[](void*, void*) noexcept { } } namespace std { template [[nodiscard]] constexpr _Tp* launder(_Tp* __p) noexcept { if constexpr (__is_same(const volatile _Tp, const volatile void)) static_assert(!__is_same(const volatile _Tp, const volatile void), "std::launder argument must not be a void pointer"); else if constexpr (__is_function(_Tp)) static_assert(!__is_function(_Tp), "std::launder argument must not be a function pointer"); else return __builtin_launder(__p); return nullptr; } inline constexpr size_t hardware_destructive_interference_size = 32; inline constexpr size_t hardware_constructive_interference_size = 32; # 264 "/usr/include/c++/15/new" 3 } #pragma GCC visibility pop #pragma GCC diagnostic pop # 42 "/usr/include/c++/15/bits/std_function.h" 2 3 # 1 "/usr/include/c++/15/typeinfo" 1 3 # 42 "/usr/include/c++/15/typeinfo" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 43 "/usr/include/c++/15/typeinfo" 2 3 #pragma GCC visibility push(default) extern "C++" { namespace __cxxabiv1 { class __class_type_info; } # 85 "/usr/include/c++/15/typeinfo" 3 namespace std { class type_info { public: virtual ~type_info(); const char* name() const noexcept { return __name[0] == '*' ? __name + 1 : __name; } bool before(const type_info& __arg) const noexcept; bool operator==(const type_info& __arg) const noexcept; bool operator!=(const type_info& __arg) const noexcept { return !operator==(__arg); } size_t hash_code() const noexcept { return _Hash_bytes(name(), __builtin_strlen(name()), static_cast(0xc70f6907UL)); } virtual bool __is_pointer_p() const; virtual bool __is_function_p() const; virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, unsigned __outer) const; virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, void **__obj_ptr) const; protected: const char *__name; explicit type_info(const char *__n): __name(__n) { } private: type_info& operator=(const type_info&) = delete; type_info(const type_info&) = delete; # 168 "/usr/include/c++/15/typeinfo" 3 }; inline bool type_info::before(const type_info& __arg) const noexcept { if (__name[0] != '*' || __arg.__name[0] != '*') return __builtin_strcmp (__name, __arg.__name) < 0; # 188 "/usr/include/c++/15/typeinfo" 3 return __name < __arg.__name; } inline bool type_info::operator==(const type_info& __arg) const noexcept { if (std::__is_constant_evaluated()) return this == &__arg; if (__name == __arg.__name) return true; return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; } # 224 "/usr/include/c++/15/typeinfo" 3 class bad_cast : public exception { public: bad_cast() noexcept { } virtual ~bad_cast() noexcept; virtual const char* what() const noexcept; }; class bad_typeid : public exception { public: bad_typeid () noexcept { } virtual ~bad_typeid() noexcept; virtual const char* what() const noexcept; }; } } #pragma GCC visibility pop # 43 "/usr/include/c++/15/bits/std_function.h" 2 3 # 1 "/usr/include/c++/15/bits/functexcept.h" 1 3 # 40 "/usr/include/c++/15/bits/functexcept.h" 3 # 1 "/usr/include/c++/15/bits/exception_defines.h" 1 3 # 41 "/usr/include/c++/15/bits/functexcept.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { void __throw_bad_exception(void) __attribute__((__noreturn__)); void __throw_bad_alloc(void) __attribute__((__noreturn__)); void __throw_bad_array_new_length(void) __attribute__((__noreturn__)); void __throw_bad_cast(void) __attribute__((__noreturn__,__cold__)); void __throw_bad_typeid(void) __attribute__((__noreturn__,__cold__)); void __throw_logic_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_domain_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_invalid_argument(const char*) __attribute__((__noreturn__,__cold__)); void __throw_length_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__)); void __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__,__cold__)) __attribute__((__format__(__gnu_printf__, 1, 2))); void __throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_range_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_underflow_error(const char*) __attribute__((__noreturn__,__cold__)); void __throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__)); void __throw_ios_failure(const char*, int) __attribute__((__noreturn__,__cold__)); void __throw_system_error(int) __attribute__((__noreturn__,__cold__)); void __throw_future_error(int) __attribute__((__noreturn__,__cold__)); void __throw_bad_function_call() __attribute__((__noreturn__,__cold__)); # 140 "/usr/include/c++/15/bits/functexcept.h" 3 } # 46 "/usr/include/c++/15/bits/std_function.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { class bad_function_call : public std::exception { public: virtual ~bad_function_call() noexcept; const char* what() const noexcept; }; template struct __is_location_invariant : is_trivially_copyable<_Tp>::type { }; class _Undefined_class; union _Nocopy_types { void* _M_object; const void* _M_const_object; void (*_M_function_pointer)(); void (_Undefined_class::*_M_member_pointer)(); }; union [[gnu::may_alias]] _Any_data { void* _M_access() noexcept { return &_M_pod_data[0]; } const void* _M_access() const noexcept { return &_M_pod_data[0]; } template _Tp& _M_access() noexcept { return *static_cast<_Tp*>(_M_access()); } template const _Tp& _M_access() const noexcept { return *static_cast(_M_access()); } _Nocopy_types _M_unused; char _M_pod_data[sizeof(_Nocopy_types)]; }; enum _Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }; template class function; class _Function_base { public: static const size_t _M_max_size = sizeof(_Nocopy_types); static const size_t _M_max_align = __alignof__(_Nocopy_types); template class _Base_manager { protected: static const bool __stored_locally = (__is_location_invariant<_Functor>::value && sizeof(_Functor) <= _M_max_size && __alignof__(_Functor) <= _M_max_align && (_M_max_align % __alignof__(_Functor) == 0)); using _Local_storage = integral_constant; static _Functor* _M_get_pointer(const _Any_data& __source) noexcept { if constexpr (__stored_locally) { const _Functor& __f = __source._M_access<_Functor>(); return const_cast<_Functor*>(std::__addressof(__f)); } else return __source._M_access<_Functor*>(); } private: template static void _M_create(_Any_data& __dest, _Fn&& __f, true_type) { ::new (__dest._M_access()) _Functor(std::forward<_Fn>(__f)); } template static void _M_create(_Any_data& __dest, _Fn&& __f, false_type) { __dest._M_access<_Functor*>() = new _Functor(std::forward<_Fn>(__f)); } static void _M_destroy(_Any_data& __victim, true_type) { __victim._M_access<_Functor>().~_Functor(); } static void _M_destroy(_Any_data& __victim, false_type) { delete __victim._M_access<_Functor*>(); } public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { case __get_type_info: __dest._M_access() = &typeid(_Functor); break; case __get_functor_ptr: __dest._M_access<_Functor*>() = _M_get_pointer(__source); break; case __clone_functor: _M_init_functor(__dest, *const_cast(_M_get_pointer(__source))); break; case __destroy_functor: _M_destroy(__dest, _Local_storage()); break; } return false; } template static void _M_init_functor(_Any_data& __functor, _Fn&& __f) noexcept(__and_<_Local_storage, is_nothrow_constructible<_Functor, _Fn>>::value) { _M_create(__functor, std::forward<_Fn>(__f), _Local_storage()); } template static bool _M_not_empty_function(const function<_Signature>& __f) noexcept { return static_cast(__f); } template static bool _M_not_empty_function(_Tp* __fp) noexcept { return __fp != nullptr; } template static bool _M_not_empty_function(_Tp _Class::* __mp) noexcept { return __mp != nullptr; } template static bool _M_not_empty_function(const _Tp&) noexcept { return true; } }; _Function_base() = default; ~_Function_base() { if (_M_manager) _M_manager(_M_functor, _M_functor, __destroy_functor); } bool _M_empty() const { return !_M_manager; } using _Manager_type = bool (*)(_Any_data&, const _Any_data&, _Manager_operation); _Any_data _M_functor{}; _Manager_type _M_manager{}; }; template class _Function_handler; template class _Function_handler<_Res(_ArgTypes...), _Functor> : public _Function_base::_Base_manager<_Functor> { using _Base = _Function_base::_Base_manager<_Functor>; public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { case __get_type_info: __dest._M_access() = &typeid(_Functor); break; case __get_functor_ptr: __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source); break; default: _Base::_M_manager(__dest, __source, __op); } return false; } static _Res _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) { return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor), std::forward<_ArgTypes>(__args)...); } template static constexpr bool _S_nothrow_init() noexcept { return __and_>::value; } }; template<> class _Function_handler { public: static bool _M_manager(_Any_data&, const _Any_data&, _Manager_operation) { return false; } }; template::value> struct _Target_handler : _Function_handler<_Signature, typename remove_cv<_Functor>::type> { }; template struct _Target_handler<_Signature, _Functor, false> : _Function_handler { }; template class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, private _Function_base { template, function>::value> using _Decay_t = typename __enable_if_t>::type; template, typename _Res2 = __invoke_result<_DFunc&, _ArgTypes...>> struct _Callable : __is_invocable_impl<_Res2, _Res>::type { }; template using _Requires = __enable_if_t<_Cond::value, _Tp>; template using _Handler = _Function_handler<_Res(_ArgTypes...), __decay_t<_Functor>>; public: typedef _Res result_type; function() noexcept : _Function_base() { } function(nullptr_t) noexcept : _Function_base() { } # 388 "/usr/include/c++/15/bits/std_function.h" 3 function(const function& __x) : _Function_base() { if (static_cast(__x)) { __x._M_manager(_M_functor, __x._M_functor, __clone_functor); _M_invoker = __x._M_invoker; _M_manager = __x._M_manager; } } # 406 "/usr/include/c++/15/bits/std_function.h" 3 function(function&& __x) noexcept : _Function_base(), _M_invoker(__x._M_invoker) { if (static_cast(__x)) { _M_functor = __x._M_functor; _M_manager = __x._M_manager; __x._M_manager = nullptr; __x._M_invoker = nullptr; } } # 435 "/usr/include/c++/15/bits/std_function.h" 3 template>> function(_Functor&& __f) noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) : _Function_base() { static_assert(is_copy_constructible<__decay_t<_Functor>>::value, "std::function target must be copy-constructible"); static_assert(is_constructible<__decay_t<_Functor>, _Functor>::value, "std::function target must be constructible from the " "constructor argument"); using _My_handler = _Handler<_Functor>; if (_My_handler::_M_not_empty_function(__f)) { _My_handler::_M_init_functor(_M_functor, std::forward<_Functor>(__f)); _M_invoker = &_My_handler::_M_invoke; _M_manager = &_My_handler::_M_manager; } } # 470 "/usr/include/c++/15/bits/std_function.h" 3 function& operator=(const function& __x) { function(__x).swap(*this); return *this; } # 488 "/usr/include/c++/15/bits/std_function.h" 3 function& operator=(function&& __x) noexcept { function(std::move(__x)).swap(*this); return *this; } # 502 "/usr/include/c++/15/bits/std_function.h" 3 function& operator=(nullptr_t) noexcept { if (_M_manager) { _M_manager(_M_functor, _M_functor, __destroy_functor); _M_manager = nullptr; _M_invoker = nullptr; } return *this; } # 531 "/usr/include/c++/15/bits/std_function.h" 3 template _Requires<_Callable<_Functor>, function&> operator=(_Functor&& __f) noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) { function(std::forward<_Functor>(__f)).swap(*this); return *this; } template function& operator=(reference_wrapper<_Functor> __f) noexcept { function(__f).swap(*this); return *this; } # 558 "/usr/include/c++/15/bits/std_function.h" 3 void swap(function& __x) noexcept { std::swap(_M_functor, __x._M_functor); std::swap(_M_manager, __x._M_manager); std::swap(_M_invoker, __x._M_invoker); } # 575 "/usr/include/c++/15/bits/std_function.h" 3 explicit operator bool() const noexcept { return !_M_empty(); } # 588 "/usr/include/c++/15/bits/std_function.h" 3 _Res operator()(_ArgTypes... __args) const { if (_M_empty()) __throw_bad_function_call(); return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); } # 607 "/usr/include/c++/15/bits/std_function.h" 3 const type_info& target_type() const noexcept { if (_M_manager) { _Any_data __typeinfo_result; _M_manager(__typeinfo_result, _M_functor, __get_type_info); if (auto __ti = __typeinfo_result._M_access()) return *__ti; } return typeid(void); } # 632 "/usr/include/c++/15/bits/std_function.h" 3 template _Functor* target() noexcept { const function* __const_this = this; const _Functor* __func = __const_this->template target<_Functor>(); return *const_cast<_Functor**>(&__func); } template const _Functor* target() const noexcept { if constexpr (is_object<_Functor>::value) { using _Handler = _Target_handler<_Res(_ArgTypes...), _Functor>; if (_M_manager == &_Handler::_M_manager || (_M_manager && typeid(_Functor) == target_type()) ) { _Any_data __ptr; _M_manager(__ptr, _M_functor, __get_functor_ptr); return __ptr._M_access(); } } return nullptr; } private: using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); _Invoker_type _M_invoker = nullptr; }; template struct __function_guide_helper { }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) noexcept(_Nx) > { using type = _Res(_Args...); }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) & noexcept(_Nx) > { using type = _Res(_Args...); }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) const noexcept(_Nx) > { using type = _Res(_Args...); }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) const & noexcept(_Nx) > { using type = _Res(_Args...); }; # 725 "/usr/include/c++/15/bits/std_function.h" 3 template using __function_guide_t = typename __function_guide_helper<_Op>::type; template function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; template> function(_Fn) -> function<_Signature>; # 745 "/usr/include/c++/15/bits/std_function.h" 3 template inline bool operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept { return !static_cast(__f); } template inline bool operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept { return !static_cast(__f); } template inline bool operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept { return static_cast(__f); } template inline bool operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept { return static_cast(__f); } # 784 "/usr/include/c++/15/bits/std_function.h" 3 template inline void swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept { __x.swap(__y); } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::true_type { }; } } # 62 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/unordered_map" 1 3 # 36 "/usr/include/c++/15/unordered_map" 3 # 1 "/usr/include/c++/15/bits/requires_hosted.h" 1 3 # 37 "/usr/include/c++/15/unordered_map" 2 3 # 1 "/usr/include/c++/15/initializer_list" 1 3 # 43 "/usr/include/c++/15/initializer_list" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class initializer_list { public: typedef _E value_type; typedef const _E& reference; typedef const _E& const_reference; typedef size_t size_type; typedef const _E* iterator; typedef const _E* const_iterator; private: iterator _M_array; size_type _M_len; constexpr initializer_list(const_iterator __a, size_type __l) : _M_array(__a), _M_len(__l) { } public: constexpr initializer_list() noexcept : _M_array(0), _M_len(0) { } constexpr size_type size() const noexcept { return _M_len; } constexpr const_iterator begin() const noexcept { return _M_array; } constexpr const_iterator end() const noexcept { return begin() + size(); } }; template constexpr const _Tp* begin(initializer_list<_Tp> __ils) noexcept { return __ils.begin(); } template constexpr const _Tp* end(initializer_list<_Tp> __ils) noexcept { return __ils.end(); } } # 43 "/usr/include/c++/15/unordered_map" 2 3 # 1 "/usr/include/c++/15/bits/unordered_map.h" 1 3 # 33 "/usr/include/c++/15/bits/unordered_map.h" 3 # 1 "/usr/include/c++/15/bits/hashtable.h" 1 3 # 37 "/usr/include/c++/15/bits/hashtable.h" 3 # 1 "/usr/include/c++/15/bits/hashtable_policy.h" 1 3 # 36 "/usr/include/c++/15/bits/hashtable_policy.h" 3 # 1 "/usr/include/c++/15/bits/stl_algobase.h" 1 3 # 61 "/usr/include/c++/15/bits/stl_algobase.h" 3 # 1 "/usr/include/c++/15/bits/cpp_type_traits.h" 1 3 # 40 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 41 "/usr/include/c++/15/bits/cpp_type_traits.h" 2 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" # 76 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { struct __true_type { }; struct __false_type { }; template struct __truth_type { typedef __false_type __type; }; template<> struct __truth_type { typedef __true_type __type; }; template struct __traitor { enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; typedef typename __truth_type<__value>::__type __type; }; template struct __are_same { enum { __value = 0 }; typedef __false_type __type; }; template struct __are_same<_Tp, _Tp> { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_integer { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; # 176 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; # 264 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 __extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; # 281 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 template struct __is_floating { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; # 358 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 template struct __is_arithmetic : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > { }; template struct __is_char { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_char { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_char { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_byte { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; enum class byte : unsigned char; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; # 438 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 template struct __is_nonvolatile_trivially_copyable { enum { __value = __is_trivially_copyable(_Tp) }; }; template struct __is_nonvolatile_trivially_copyable { enum { __value = 0 }; }; template struct __memcpyable { enum { __value = 0 }; }; template struct __memcpyable<_Tp*, _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcpyable<_Tp*, const _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcpyable_integer; template struct __memcpyable<_Tp*, _Up*> { enum { __value = __memcpyable_integer<_Tp>::__width != 0 && ((int)__memcpyable_integer<_Tp>::__width == (int)__memcpyable_integer<_Up>::__width) }; }; template struct __memcpyable<_Tp*, const _Up*> : __memcpyable<_Tp*, _Up*> { }; template struct __memcpyable_integer { enum { __width = __is_integer<_Tp>::__value ? (sizeof(_Tp) * 8) : 0 }; }; template struct __memcpyable_integer { enum { __width = 0 }; }; # 592 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 template struct __memcmpable { enum { __value = 0 }; }; template struct __memcmpable<_Tp*, _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcmpable : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcmpable<_Tp*, const _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template::__value > struct __is_memcmp_ordered { static const bool __value = _Tp(-1) > _Tp(1); }; template struct __is_memcmp_ordered<_Tp, false> { static const bool __value = false; }; template struct __is_memcmp_ordered_with { static const bool __value = __is_memcmp_ordered<_Tp>::__value && __is_memcmp_ordered<_Up>::__value; }; template struct __is_memcmp_ordered_with<_Tp, _Up, false> { static const bool __value = false; }; # 661 "/usr/include/c++/15/bits/cpp_type_traits.h" 3 template<> struct __is_memcmp_ordered_with { static constexpr bool __value = true; }; template struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> { static constexpr bool __value = false; }; template struct __is_memcmp_ordered_with { static constexpr bool __value = false; }; template constexpr bool __can_use_memchr_for_find = __is_byte<_ValT>::__value && (is_same_v<_Tp, _ValT> || is_integral_v<_Tp>); template struct __is_move_iterator { enum { __value = 0 }; typedef __false_type __type; }; template inline _Iterator __miter_base(_Iterator __it) { return __it; } } } #pragma GCC diagnostic pop # 62 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/ext/type_traits.h" 1 3 # 39 "/usr/include/c++/15/ext/type_traits.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" extern "C++" { namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template struct __enable_if { }; template struct __enable_if { typedef _Tp __type; }; template struct __conditional_type { typedef _Iftrue __type; }; template struct __conditional_type { typedef _Iffalse __type; }; template struct __add_unsigned { private: typedef __enable_if::__value, _Tp> __if_type; public: typedef typename __if_type::__type __type; }; template<> struct __add_unsigned { typedef unsigned char __type; }; template<> struct __add_unsigned { typedef unsigned char __type; }; template<> struct __add_unsigned { typedef unsigned short __type; }; template<> struct __add_unsigned { typedef unsigned int __type; }; template<> struct __add_unsigned { typedef unsigned long __type; }; template<> struct __add_unsigned { typedef unsigned long long __type; }; template<> struct __add_unsigned; template<> struct __add_unsigned; template struct __remove_unsigned { private: typedef __enable_if::__value, _Tp> __if_type; public: typedef typename __if_type::__type __type; }; template<> struct __remove_unsigned { typedef signed char __type; }; template<> struct __remove_unsigned { typedef signed char __type; }; template<> struct __remove_unsigned { typedef short __type; }; template<> struct __remove_unsigned { typedef int __type; }; template<> struct __remove_unsigned { typedef long __type; }; template<> struct __remove_unsigned { typedef long long __type; }; template<> struct __remove_unsigned; template<> struct __remove_unsigned; template constexpr inline bool __is_null_pointer(_Type* __ptr) { return __ptr == 0; } template constexpr inline bool __is_null_pointer(_Type) { return false; } constexpr bool __is_null_pointer(std::nullptr_t) { return true; } template::__value> struct __promote { typedef double __type; }; template struct __promote<_Tp, false> { }; template<> struct __promote { typedef long double __type; }; template<> struct __promote { typedef double __type; }; template<> struct __promote { typedef float __type; }; # 230 "/usr/include/c++/15/ext/type_traits.h" 3 template using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); template using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; template using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; template using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; # 274 "/usr/include/c++/15/ext/type_traits.h" 3 } } #pragma GCC diagnostic pop # 63 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/ext/numeric_traits.h" 1 3 # 39 "/usr/include/c++/15/ext/numeric_traits.h" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 52 "/usr/include/c++/15/ext/numeric_traits.h" 3 template struct __is_integer_nonstrict : public std::__is_integer<_Tp> { using std::__is_integer<_Tp>::__value; enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; }; template struct __numeric_traits_integer { static_assert(__is_integer_nonstrict<_Value>::__value, "invalid specialization"); static const bool __is_signed = (_Value)(-1) < 0; static const int __digits = __is_integer_nonstrict<_Value>::__width - __is_signed; static const _Value __max = __is_signed ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) : ~(_Value)0; static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; }; template const _Value __numeric_traits_integer<_Value>::__min; template const _Value __numeric_traits_integer<_Value>::__max; template const bool __numeric_traits_integer<_Value>::__is_signed; template const int __numeric_traits_integer<_Value>::__digits; # 139 "/usr/include/c++/15/ext/numeric_traits.h" 3 template using __int_traits = __numeric_traits_integer<_Tp>; # 159 "/usr/include/c++/15/ext/numeric_traits.h" 3 template struct __numeric_traits_floating { static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 113) * 643L / 2136); static const bool __is_signed = true; static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 33); static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); }; template const int __numeric_traits_floating<_Value>::__max_digits10; template const bool __numeric_traits_floating<_Value>::__is_signed; template const int __numeric_traits_floating<_Value>::__digits10; template const int __numeric_traits_floating<_Value>::__max_exponent10; template struct __numeric_traits : public __numeric_traits_integer<_Value> { }; template<> struct __numeric_traits : public __numeric_traits_floating { }; template<> struct __numeric_traits : public __numeric_traits_floating { }; template<> struct __numeric_traits : public __numeric_traits_floating { }; # 240 "/usr/include/c++/15/ext/numeric_traits.h" 3 } # 64 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/bits/stl_iterator_base_types.h" 1 3 # 76 "/usr/include/c++/15/bits/stl_iterator_base_types.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 95 "/usr/include/c++/15/bits/stl_iterator_base_types.h" 3 struct input_iterator_tag { }; struct output_iterator_tag { }; struct forward_iterator_tag : public input_iterator_tag { }; struct bidirectional_iterator_tag : public forward_iterator_tag { }; struct random_access_iterator_tag : public bidirectional_iterator_tag { }; # 127 "/usr/include/c++/15/bits/stl_iterator_base_types.h" 3 template struct [[__deprecated__]] iterator { typedef _Category iterator_category; typedef _Tp value_type; typedef _Distance difference_type; typedef _Pointer pointer; typedef _Reference reference; }; # 151 "/usr/include/c++/15/bits/stl_iterator_base_types.h" 3 template struct iterator_traits; template> struct __iterator_traits { }; template struct __iterator_traits<_Iterator, __void_t> { typedef typename _Iterator::iterator_category iterator_category; typedef typename _Iterator::value_type value_type; typedef typename _Iterator::difference_type difference_type; typedef typename _Iterator::pointer pointer; typedef typename _Iterator::reference reference; }; template struct iterator_traits : public __iterator_traits<_Iterator> { }; # 211 "/usr/include/c++/15/bits/stl_iterator_base_types.h" 3 template struct iterator_traits<_Tp*> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef _Tp& reference; }; template struct iterator_traits { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef const _Tp* pointer; typedef const _Tp& reference; }; template __attribute__((__always_inline__)) inline constexpr typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&) { return typename iterator_traits<_Iter>::iterator_category(); } template using __iter_category_t = typename iterator_traits<_Iter>::iterator_category; template using _RequireInputIter = __enable_if_t, input_iterator_tag>::value>; template> struct __is_random_access_iter : is_base_of { typedef is_base_of _Base; enum { __value = _Base::value }; }; } # 66 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/bits/stl_iterator_base_funcs.h" 1 3 # 66 "/usr/include/c++/15/bits/stl_iterator_base_funcs.h" 3 # 1 "/usr/include/c++/15/bits/concept_check.h" 1 3 # 39 "/usr/include/c++/15/bits/concept_check.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wvariadic-macros" # 86 "/usr/include/c++/15/bits/concept_check.h" 3 #pragma GCC diagnostic pop # 67 "/usr/include/c++/15/bits/stl_iterator_base_funcs.h" 2 3 # 1 "/usr/include/c++/15/debug/assertions.h" 1 3 # 68 "/usr/include/c++/15/bits/stl_iterator_base_funcs.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _List_iterator; template struct _List_const_iterator; template inline constexpr typename iterator_traits<_InputIterator>::difference_type __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) { typename iterator_traits<_InputIterator>::difference_type __n = 0; while (__first != __last) { ++__first; ++__n; } return __n; } template __attribute__((__always_inline__)) inline constexpr typename iterator_traits<_RandomAccessIterator>::difference_type __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) { return __last - __first; } template ptrdiff_t __distance(std::_List_iterator<_Tp>, std::_List_iterator<_Tp>, input_iterator_tag); template ptrdiff_t __distance(std::_List_const_iterator<_Tp>, std::_List_const_iterator<_Tp>, input_iterator_tag); template void __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; # 146 "/usr/include/c++/15/bits/stl_iterator_base_funcs.h" 3 template [[__nodiscard__]] __attribute__((__always_inline__)) inline constexpr typename iterator_traits<_InputIterator>::difference_type distance(_InputIterator __first, _InputIterator __last) { return std::__distance(__first, __last, std::__iterator_category(__first)); } template inline constexpr void __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) { do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); while (__n--) ++__i; } template inline constexpr void __advance(_BidirectionalIterator& __i, _Distance __n, bidirectional_iterator_tag) { if (__n > 0) while (__n--) ++__i; else while (__n++) --__i; } template inline constexpr void __advance(_RandomAccessIterator& __i, _Distance __n, random_access_iterator_tag) { if (__builtin_constant_p(__n) && __n == 1) ++__i; else if (__builtin_constant_p(__n) && __n == -1) --__i; else __i += __n; } template void __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; # 219 "/usr/include/c++/15/bits/stl_iterator_base_funcs.h" 3 template __attribute__((__always_inline__)) inline constexpr void advance(_InputIterator& __i, _Distance __n) { typename iterator_traits<_InputIterator>::difference_type __d = __n; std::__advance(__i, __d, std::__iterator_category(__i)); } template [[__nodiscard__]] [[__gnu__::__always_inline__]] inline constexpr _InputIterator next(_InputIterator __x, typename iterator_traits<_InputIterator>::difference_type __n = 1) { std::advance(__x, __n); return __x; } template [[__nodiscard__]] [[__gnu__::__always_inline__]] inline constexpr _BidirectionalIterator prev(_BidirectionalIterator __x, typename iterator_traits<_BidirectionalIterator>::difference_type __n = 1) { std::advance(__x, -__n); return __x; } } # 67 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/bits/stl_iterator.h" 1 3 # 67 "/usr/include/c++/15/bits/stl_iterator.h" 3 # 1 "/usr/include/c++/15/bits/ptr_traits.h" 1 3 # 42 "/usr/include/c++/15/bits/ptr_traits.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { class __undefined; template struct __get_first_arg { using type = __undefined; }; template class _SomeTemplate, typename _Tp, typename... _Types> struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> { using type = _Tp; }; template struct __replace_first_arg { }; template class _SomeTemplate, typename _Up, typename _Tp, typename... _Types> struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> { using type = _SomeTemplate<_Up, _Types...>; }; template struct __ptr_traits_elem : __get_first_arg<_Ptr> { }; template struct __ptr_traits_elem<_Ptr, __void_t> { using type = typename _Ptr::element_type; }; template using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; template::value> struct __ptr_traits_ptr_to { using pointer = _Ptr; using element_type = _Elt; static pointer pointer_to(element_type& __r) { return pointer::pointer_to(__r); } }; template struct __ptr_traits_ptr_to<_Ptr, _Elt, true> { }; template struct __ptr_traits_ptr_to<_Tp*, _Tp, false> { using pointer = _Tp*; using element_type = _Tp; static pointer pointer_to(element_type& __r) noexcept { return std::addressof(__r); } }; template struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> { private: template using __diff_t = typename _Tp::difference_type; template using __rebind = __type_identity>; public: using pointer = _Ptr; using element_type = _Elt; using difference_type = __detected_or_t; template using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, __rebind, _Ptr, _Up>::type; }; template struct __ptr_traits_impl<_Ptr, __undefined> { }; template struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> { }; template struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> { typedef _Tp* pointer; typedef _Tp element_type; typedef ptrdiff_t difference_type; template using rebind = _Up*; }; template using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; template [[__gnu__::__always_inline__]] constexpr _Tp* __to_address(_Tp* __ptr) noexcept { static_assert(!std::is_function<_Tp>::value, "std::to_address argument " "must not be a function pointer"); return __ptr; } template constexpr typename std::pointer_traits<_Ptr>::element_type* __to_address(const _Ptr& __ptr) { return std::__to_address(__ptr.operator->()); } # 268 "/usr/include/c++/15/bits/ptr_traits.h" 3 } # 68 "/usr/include/c++/15/bits/stl_iterator.h" 2 3 # 85 "/usr/include/c++/15/bits/stl_iterator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 108 "/usr/include/c++/15/bits/stl_iterator.h" 3 # 108 "/usr/include/c++/15/bits/stl_iterator.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" # 130 "/usr/include/c++/15/bits/stl_iterator.h" 3 template class reverse_iterator : public iterator::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> { template friend class reverse_iterator; # 149 "/usr/include/c++/15/bits/stl_iterator.h" 3 protected: _Iterator current; typedef iterator_traits<_Iterator> __traits_type; public: typedef _Iterator iterator_type; typedef typename __traits_type::pointer pointer; typedef typename __traits_type::difference_type difference_type; typedef typename __traits_type::reference reference; # 180 "/usr/include/c++/15/bits/stl_iterator.h" 3 constexpr reverse_iterator() noexcept(noexcept(_Iterator())) : current() { } explicit constexpr reverse_iterator(iterator_type __x) noexcept(noexcept(_Iterator(__x))) : current(__x) { } constexpr reverse_iterator(const reverse_iterator& __x) noexcept(noexcept(_Iterator(__x.current))) : current(__x.current) { } reverse_iterator& operator=(const reverse_iterator&) = default; template constexpr reverse_iterator(const reverse_iterator<_Iter>& __x) noexcept(noexcept(_Iterator(__x.current))) : current(__x.current) { } template constexpr reverse_iterator& operator=(const reverse_iterator<_Iter>& __x) noexcept(noexcept(current = __x.current)) { current = __x.current; return *this; } [[__nodiscard__]] constexpr iterator_type base() const noexcept(noexcept(_Iterator(current))) { return current; } # 257 "/usr/include/c++/15/bits/stl_iterator.h" 3 [[__nodiscard__]] constexpr reference operator*() const { _Iterator __tmp = current; return *--__tmp; } [[__nodiscard__]] constexpr pointer operator->() const { _Iterator __tmp = current; --__tmp; return _S_to_pointer(__tmp); } constexpr reverse_iterator& operator++() { --current; return *this; } constexpr reverse_iterator operator++(int) { reverse_iterator __tmp = *this; --current; return __tmp; } constexpr reverse_iterator& operator--() { ++current; return *this; } constexpr reverse_iterator operator--(int) { reverse_iterator __tmp = *this; ++current; return __tmp; } [[__nodiscard__]] constexpr reverse_iterator operator+(difference_type __n) const { return reverse_iterator(current - __n); } constexpr reverse_iterator& operator+=(difference_type __n) { current -= __n; return *this; } [[__nodiscard__]] constexpr reverse_iterator operator-(difference_type __n) const { return reverse_iterator(current + __n); } constexpr reverse_iterator& operator-=(difference_type __n) { current += __n; return *this; } [[__nodiscard__]] constexpr reference operator[](difference_type __n) const { return *(*this + __n); } # 417 "/usr/include/c++/15/bits/stl_iterator.h" 3 private: template static constexpr _Tp* _S_to_pointer(_Tp* __p) { return __p; } template static constexpr pointer _S_to_pointer(_Tp __t) { return __t.operator->(); } }; # 440 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline constexpr bool operator==(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __x.base() == __y.base(); } template [[__nodiscard__]] inline constexpr bool operator<(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y.base() < __x.base(); } template [[__nodiscard__]] inline constexpr bool operator!=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__x == __y); } template [[__nodiscard__]] inline constexpr bool operator>(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y < __x; } template [[__nodiscard__]] inline constexpr bool operator<=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline constexpr bool operator>=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__x < __y); } template [[__nodiscard__]] inline constexpr bool operator==(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() == __y.base(); } template [[__nodiscard__]] inline constexpr bool operator<(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() > __y.base(); } template [[__nodiscard__]] inline constexpr bool operator!=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() != __y.base(); } template [[__nodiscard__]] inline constexpr bool operator>(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() < __y.base(); } template inline constexpr bool operator<=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() >= __y.base(); } template [[__nodiscard__]] inline constexpr bool operator>=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() <= __y.base(); } # 617 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline constexpr auto operator-(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) -> decltype(__y.base() - __x.base()) { return __y.base() - __x.base(); } template [[__nodiscard__]] inline constexpr reverse_iterator<_Iterator> operator+(typename reverse_iterator<_Iterator>::difference_type __n, const reverse_iterator<_Iterator>& __x) { return reverse_iterator<_Iterator>(__x.base() - __n); } template inline constexpr reverse_iterator<_Iterator> __make_reverse_iterator(_Iterator __i) { return reverse_iterator<_Iterator>(__i); } template [[__nodiscard__]] inline constexpr reverse_iterator<_Iterator> make_reverse_iterator(_Iterator __i) { return reverse_iterator<_Iterator>(__i); } # 659 "/usr/include/c++/15/bits/stl_iterator.h" 3 template struct __is_move_iterator > : __is_move_iterator<_Iterator> { }; # 676 "/usr/include/c++/15/bits/stl_iterator.h" 3 template class back_insert_iterator : public iterator { protected: _Container* container; public: typedef _Container container_type; explicit back_insert_iterator(_Container& __x) : container(std::__addressof(__x)) { } # 714 "/usr/include/c++/15/bits/stl_iterator.h" 3 back_insert_iterator& operator=(const typename _Container::value_type& __value) { container->push_back(__value); return *this; } back_insert_iterator& operator=(typename _Container::value_type&& __value) { container->push_back(std::move(__value)); return *this; } [[__nodiscard__]] back_insert_iterator& operator*() { return *this; } back_insert_iterator& operator++() { return *this; } back_insert_iterator operator++(int) { return *this; } }; # 761 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline back_insert_iterator<_Container> back_inserter(_Container& __x) { return back_insert_iterator<_Container>(__x); } # 777 "/usr/include/c++/15/bits/stl_iterator.h" 3 template class front_insert_iterator : public iterator { protected: _Container* container; public: typedef _Container container_type; explicit front_insert_iterator(_Container& __x) : container(std::__addressof(__x)) { } # 815 "/usr/include/c++/15/bits/stl_iterator.h" 3 front_insert_iterator& operator=(const typename _Container::value_type& __value) { container->push_front(__value); return *this; } front_insert_iterator& operator=(typename _Container::value_type&& __value) { container->push_front(std::move(__value)); return *this; } [[__nodiscard__]] front_insert_iterator& operator*() { return *this; } front_insert_iterator& operator++() { return *this; } front_insert_iterator operator++(int) { return *this; } }; # 862 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline front_insert_iterator<_Container> front_inserter(_Container& __x) { return front_insert_iterator<_Container>(__x); } # 882 "/usr/include/c++/15/bits/stl_iterator.h" 3 template class insert_iterator : public iterator { typedef typename _Container::iterator _Iter; protected: _Container* container; _Iter iter; public: typedef _Container container_type; # 907 "/usr/include/c++/15/bits/stl_iterator.h" 3 insert_iterator(_Container& __x, _Iter __i) : container(std::__addressof(__x)), iter(__i) {} # 943 "/usr/include/c++/15/bits/stl_iterator.h" 3 insert_iterator& operator=(const typename _Container::value_type& __value) { iter = container->insert(iter, __value); ++iter; return *this; } insert_iterator& operator=(typename _Container::value_type&& __value) { iter = container->insert(iter, std::move(__value)); ++iter; return *this; } [[__nodiscard__]] insert_iterator& operator*() { return *this; } insert_iterator& operator++() { return *this; } insert_iterator& operator++(int) { return *this; } }; #pragma GCC diagnostic pop # 1002 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline insert_iterator<_Container> inserter(_Container& __x, typename _Container::iterator __i) { return insert_iterator<_Container>(__x, __i); } } namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 1025 "/usr/include/c++/15/bits/stl_iterator.h" 3 template class __normal_iterator { protected: _Iterator _M_current; typedef std::iterator_traits<_Iterator> __traits_type; template using __convertible_from = std::__enable_if_t::value>; public: typedef _Iterator iterator_type; typedef typename __traits_type::iterator_category iterator_category; typedef typename __traits_type::value_type value_type; typedef typename __traits_type::difference_type difference_type; typedef typename __traits_type::reference reference; typedef typename __traits_type::pointer pointer; __attribute__((__always_inline__)) constexpr __normal_iterator() noexcept : _M_current() { } __attribute__((__always_inline__)) explicit constexpr __normal_iterator(const _Iterator& __i) noexcept : _M_current(__i) { } template> [[__gnu__::__always_inline__]] constexpr __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) noexcept # 1082 "/usr/include/c++/15/bits/stl_iterator.h" 3 : _M_current(__i.base()) { } [[__nodiscard__]] __attribute__((__always_inline__)) constexpr reference operator*() const noexcept { return *_M_current; } [[__nodiscard__]] __attribute__((__always_inline__)) constexpr pointer operator->() const noexcept { return _M_current; } __attribute__((__always_inline__)) constexpr __normal_iterator& operator++() noexcept { ++_M_current; return *this; } __attribute__((__always_inline__)) constexpr __normal_iterator operator++(int) noexcept { return __normal_iterator(_M_current++); } __attribute__((__always_inline__)) constexpr __normal_iterator& operator--() noexcept { --_M_current; return *this; } __attribute__((__always_inline__)) constexpr __normal_iterator operator--(int) noexcept { return __normal_iterator(_M_current--); } [[__nodiscard__]] __attribute__((__always_inline__)) constexpr reference operator[](difference_type __n) const noexcept { return _M_current[__n]; } __attribute__((__always_inline__)) constexpr __normal_iterator& operator+=(difference_type __n) noexcept { _M_current += __n; return *this; } [[__nodiscard__]] __attribute__((__always_inline__)) constexpr __normal_iterator operator+(difference_type __n) const noexcept { return __normal_iterator(_M_current + __n); } __attribute__((__always_inline__)) constexpr __normal_iterator& operator-=(difference_type __n) noexcept { _M_current -= __n; return *this; } [[__nodiscard__]] __attribute__((__always_inline__)) constexpr __normal_iterator operator-(difference_type __n) const noexcept { return __normal_iterator(_M_current - __n); } [[__nodiscard__]] __attribute__((__always_inline__)) constexpr const _Iterator& base() const noexcept { return _M_current; } }; # 1217 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept { return __lhs.base() == __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator==(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() == __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept { return __lhs.base() != __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() != __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept { return __lhs.base() < __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) inline bool operator<(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() < __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept { return __lhs.base() > __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator>(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() > __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept { return __lhs.base() <= __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() <= __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept { return __lhs.base() >= __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline bool operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() >= __rhs.base(); } template [[__nodiscard__, __gnu__::__always_inline__]] constexpr auto operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept -> decltype(__lhs.base() - __rhs.base()) { return __lhs.base() - __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline typename __normal_iterator<_Iterator, _Container>::difference_type operator-(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) noexcept { return __lhs.base() - __rhs.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) constexpr inline __normal_iterator<_Iterator, _Container> operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n, const __normal_iterator<_Iterator, _Container>& __i) noexcept { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } } namespace std __attribute__ ((__visibility__ ("default"))) { # 1434 "/usr/include/c++/15/bits/stl_iterator.h" 3 template class move_iterator { _Iterator _M_current; using __traits_type = iterator_traits<_Iterator>; using __base_ref = typename __traits_type::reference; template friend class move_iterator; # 1473 "/usr/include/c++/15/bits/stl_iterator.h" 3 public: using iterator_type = _Iterator; # 1485 "/usr/include/c++/15/bits/stl_iterator.h" 3 typedef typename __traits_type::iterator_category iterator_category; typedef typename __traits_type::value_type value_type; typedef typename __traits_type::difference_type difference_type; typedef _Iterator pointer; using reference = __conditional_t::value, typename remove_reference<__base_ref>::type&&, __base_ref>; constexpr move_iterator() : _M_current() { } explicit constexpr move_iterator(iterator_type __i) : _M_current(std::move(__i)) { } template constexpr move_iterator(const move_iterator<_Iter>& __i) : _M_current(__i._M_current) { } template constexpr move_iterator& operator=(const move_iterator<_Iter>& __i) { _M_current = __i._M_current; return *this; } [[__nodiscard__]] constexpr iterator_type base() const { return _M_current; } # 1543 "/usr/include/c++/15/bits/stl_iterator.h" 3 [[__nodiscard__]] constexpr reference operator*() const { return static_cast(*_M_current); } [[__nodiscard__]] constexpr pointer operator->() const { return _M_current; } constexpr move_iterator& operator++() { ++_M_current; return *this; } constexpr move_iterator operator++(int) { move_iterator __tmp = *this; ++_M_current; return __tmp; } constexpr move_iterator& operator--() { --_M_current; return *this; } constexpr move_iterator operator--(int) { move_iterator __tmp = *this; --_M_current; return __tmp; } [[__nodiscard__]] constexpr move_iterator operator+(difference_type __n) const { return move_iterator(_M_current + __n); } constexpr move_iterator& operator+=(difference_type __n) { _M_current += __n; return *this; } [[__nodiscard__]] constexpr move_iterator operator-(difference_type __n) const { return move_iterator(_M_current - __n); } constexpr move_iterator& operator-=(difference_type __n) { _M_current -= __n; return *this; } [[__nodiscard__]] constexpr reference operator[](difference_type __n) const { return std::move(_M_current[__n]); } # 1657 "/usr/include/c++/15/bits/stl_iterator.h" 3 }; template [[__nodiscard__]] inline constexpr bool operator==(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return __x.base() == __y.base(); } # 1678 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline constexpr bool operator!=(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return !(__x == __y); } template [[__nodiscard__]] inline constexpr bool operator<(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return __x.base() < __y.base(); } template [[__nodiscard__]] inline constexpr bool operator<=(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline constexpr bool operator>(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return __y < __x; } template [[__nodiscard__]] inline constexpr bool operator>=(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return !(__x < __y); } template [[__nodiscard__]] inline constexpr bool operator==(const move_iterator<_Iterator>& __x, const move_iterator<_Iterator>& __y) { return __x.base() == __y.base(); } # 1745 "/usr/include/c++/15/bits/stl_iterator.h" 3 template [[__nodiscard__]] inline constexpr bool operator!=(const move_iterator<_Iterator>& __x, const move_iterator<_Iterator>& __y) { return !(__x == __y); } template [[__nodiscard__]] inline constexpr bool operator<(const move_iterator<_Iterator>& __x, const move_iterator<_Iterator>& __y) { return __x.base() < __y.base(); } template [[__nodiscard__]] inline constexpr bool operator<=(const move_iterator<_Iterator>& __x, const move_iterator<_Iterator>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline constexpr bool operator>(const move_iterator<_Iterator>& __x, const move_iterator<_Iterator>& __y) { return __y < __x; } template [[__nodiscard__]] inline constexpr bool operator>=(const move_iterator<_Iterator>& __x, const move_iterator<_Iterator>& __y) { return !(__x < __y); } template [[__nodiscard__]] inline constexpr auto operator-(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) -> decltype(__x.base() - __y.base()) { return __x.base() - __y.base(); } template [[__nodiscard__]] inline constexpr move_iterator<_Iterator> operator+(typename move_iterator<_Iterator>::difference_type __n, const move_iterator<_Iterator>& __x) { return __x + __n; } template [[__nodiscard__]] inline constexpr move_iterator<_Iterator> make_move_iterator(_Iterator __i) { return move_iterator<_Iterator>(std::move(__i)); } template::value_type>::value, _Iterator, move_iterator<_Iterator>>> [[__nodiscard__]] constexpr _ReturnType __make_move_if_noexcept_iterator(_Iterator __i) { return _ReturnType(__i); } template::value, const _Tp*, move_iterator<_Tp*>>> [[__nodiscard__]] constexpr _ReturnType __make_move_if_noexcept_iterator(_Tp* __i) { return _ReturnType(__i); } template struct __is_move_iterator > { enum { __value = 1 }; typedef __true_type __type; }; # 2980 "/usr/include/c++/15/bits/stl_iterator.h" 3 } namespace __gnu_debug { template class _Safe_iterator; } namespace std __attribute__ ((__visibility__ ("default"))) { template [[__nodiscard__]] __attribute__((__always_inline__)) inline _Iterator __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) { return __it.base(); } template [[__nodiscard__]] __attribute__((__always_inline__)) inline _Iterator __niter_base(_Iterator __it) noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) { return __it; } # 3027 "/usr/include/c++/15/bits/stl_iterator.h" 3 template decltype(std::__niter_base(std::declval<_Ite>())) __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, std::random_access_iterator_tag>&) noexcept(std::is_nothrow_copy_constructible<_Ite>::value); template inline auto __niter_base(reverse_iterator<_Iterator> __it) -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) { return __make_reverse_iterator(__niter_base(__it.base())); } template inline auto __niter_base(move_iterator<_Iterator> __it) -> decltype(make_move_iterator(__niter_base(__it.base()))) { return make_move_iterator(__niter_base(__it.base())); } template inline auto __miter_base(reverse_iterator<_Iterator> __it) -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) { return __make_reverse_iterator(__miter_base(__it.base())); } template inline auto __miter_base(move_iterator<_Iterator> __it) -> decltype(__miter_base(__it.base())) { return __miter_base(__it.base()); } template [[__nodiscard__]] inline _From __niter_wrap(_From __from, _To __res) { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); } template [[__nodiscard__]] __attribute__((__always_inline__)) inline _Iterator __niter_wrap(const _Iterator&, _Iterator __res) { return __res; } template using __iter_key_t = remove_const_t< typename iterator_traits<_InputIterator>::value_type::first_type>; template using __iter_val_t = typename iterator_traits<_InputIterator>::value_type::second_type; template struct pair; template using __iter_to_alloc_t = pair, __iter_val_t<_InputIterator>>; } # 68 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/debug/debug.h" 1 3 # 48 "/usr/include/c++/15/debug/debug.h" 3 namespace std { namespace __debug { } } namespace __gnu_debug { using namespace std::__debug; template struct _Safe_iterator; } # 70 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/bits/predefined_ops.h" 1 3 # 35 "/usr/include/c++/15/bits/predefined_ops.h" 3 namespace __gnu_cxx { namespace __ops { struct _Iter_less_iter { template constexpr bool operator()(_Iterator1 __it1, _Iterator2 __it2) const { return *__it1 < *__it2; } }; constexpr inline _Iter_less_iter __iter_less_iter() { return _Iter_less_iter(); } struct _Iter_less_val { constexpr _Iter_less_val() = default; explicit _Iter_less_val(_Iter_less_iter) { } template bool operator()(_Iterator __it, _Value& __val) const { return *__it < __val; } }; inline _Iter_less_val __iter_less_val() { return _Iter_less_val(); } inline _Iter_less_val __iter_comp_val(_Iter_less_iter) { return _Iter_less_val(); } struct _Val_less_iter { constexpr _Val_less_iter() = default; explicit _Val_less_iter(_Iter_less_iter) { } template bool operator()(_Value& __val, _Iterator __it) const { return __val < *__it; } }; inline _Val_less_iter __val_less_iter() { return _Val_less_iter(); } inline _Val_less_iter __val_comp_iter(_Iter_less_iter) { return _Val_less_iter(); } struct _Iter_equal_to_iter { template bool operator()(_Iterator1 __it1, _Iterator2 __it2) const { return *__it1 == *__it2; } }; inline _Iter_equal_to_iter __iter_equal_to_iter() { return _Iter_equal_to_iter(); } struct _Iter_equal_to_val { template bool operator()(_Iterator __it, _Value& __val) const { return *__it == __val; } }; inline _Iter_equal_to_val __iter_equal_to_val() { return _Iter_equal_to_val(); } inline _Iter_equal_to_val __iter_comp_val(_Iter_equal_to_iter) { return _Iter_equal_to_val(); } template struct _Iter_comp_iter { _Compare _M_comp; explicit constexpr _Iter_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) { } template constexpr bool operator()(_Iterator1 __it1, _Iterator2 __it2) { return bool(_M_comp(*__it1, *__it2)); } }; template constexpr inline _Iter_comp_iter<_Compare> __iter_comp_iter(_Compare __comp) { return _Iter_comp_iter<_Compare>(std::move(__comp)); } template struct _Iter_comp_val { _Compare _M_comp; explicit _Iter_comp_val(_Compare __comp) : _M_comp(std::move(__comp)) { } explicit _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) : _M_comp(__comp._M_comp) { } explicit _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) : _M_comp(std::move(__comp._M_comp)) { } template bool operator()(_Iterator __it, _Value& __val) { return bool(_M_comp(*__it, __val)); } }; template inline _Iter_comp_val<_Compare> __iter_comp_val(_Compare __comp) { return _Iter_comp_val<_Compare>(std::move(__comp)); } template inline _Iter_comp_val<_Compare> __iter_comp_val(_Iter_comp_iter<_Compare> __comp) { return _Iter_comp_val<_Compare>(std::move(__comp)); } template struct _Val_comp_iter { _Compare _M_comp; explicit _Val_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) { } explicit _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) : _M_comp(__comp._M_comp) { } explicit _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) : _M_comp(std::move(__comp._M_comp)) { } template bool operator()(_Value& __val, _Iterator __it) { return bool(_M_comp(__val, *__it)); } }; template inline _Val_comp_iter<_Compare> __val_comp_iter(_Compare __comp) { return _Val_comp_iter<_Compare>(std::move(__comp)); } template inline _Val_comp_iter<_Compare> __val_comp_iter(_Iter_comp_iter<_Compare> __comp) { return _Val_comp_iter<_Compare>(std::move(__comp)); } template struct _Iter_equals_val { _Value& _M_value; explicit _Iter_equals_val(_Value& __value) : _M_value(__value) { } template bool operator()(_Iterator __it) { return *__it == _M_value; } }; template inline _Iter_equals_val<_Value> __iter_equals_val(_Value& __val) { return _Iter_equals_val<_Value>(__val); } template struct _Iter_equals_iter { _Iterator1 _M_it1; explicit _Iter_equals_iter(_Iterator1 __it1) : _M_it1(__it1) { } template bool operator()(_Iterator2 __it2) { return *__it2 == *_M_it1; } }; template inline _Iter_equals_iter<_Iterator> __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) { return _Iter_equals_iter<_Iterator>(__it); } template struct _Iter_pred { _Predicate _M_pred; explicit _Iter_pred(_Predicate __pred) : _M_pred(std::move(__pred)) { } template bool operator()(_Iterator __it) { return bool(_M_pred(*__it)); } }; template inline _Iter_pred<_Predicate> __pred_iter(_Predicate __pred) { return _Iter_pred<_Predicate>(std::move(__pred)); } template struct _Iter_comp_to_val { _Compare _M_comp; _Value& _M_value; _Iter_comp_to_val(_Compare __comp, _Value& __value) : _M_comp(std::move(__comp)), _M_value(__value) { } template bool operator()(_Iterator __it) { return bool(_M_comp(*__it, _M_value)); } }; template _Iter_comp_to_val<_Compare, _Value> __iter_comp_val(_Compare __comp, _Value &__val) { return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); } template struct _Iter_comp_to_iter { _Compare _M_comp; _Iterator1 _M_it1; _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) : _M_comp(std::move(__comp)), _M_it1(__it1) { } template bool operator()(_Iterator2 __it2) { return bool(_M_comp(*__it2, *_M_it1)); } }; template inline _Iter_comp_to_iter<_Compare, _Iterator> __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) { return _Iter_comp_to_iter<_Compare, _Iterator>( std::move(__comp._M_comp), __it); } template struct _Iter_negate { _Predicate _M_pred; explicit _Iter_negate(_Predicate __pred) : _M_pred(std::move(__pred)) { } template bool operator()(_Iterator __it) { return !bool(_M_pred(*__it)); } }; template inline _Iter_negate<_Predicate> __negate(_Iter_pred<_Predicate> __pred) { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } } } # 72 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/15/bit" 1 3 # 38 "/usr/include/c++/15/bit" 3 # 1 "/usr/include/c++/15/concepts" 1 3 # 38 "/usr/include/c++/15/concepts" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 39 "/usr/include/c++/15/concepts" 2 3 # 39 "/usr/include/c++/15/bit" 2 3 # 63 "/usr/include/c++/15/bit" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 64 "/usr/include/c++/15/bit" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 157 "/usr/include/c++/15/bit" 3 template constexpr _Tp __rotl(_Tp __x, int __s) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; if constexpr ((_Nd & (_Nd - 1)) == 0) { constexpr unsigned __uNd = _Nd; const unsigned __r = __s; return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); } const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); else return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); } template constexpr _Tp __rotr(_Tp __x, int __s) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; if constexpr ((_Nd & (_Nd - 1)) == 0) { constexpr unsigned __uNd = _Nd; const unsigned __r = __s; return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); } const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); else return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); } template constexpr int __countl_zero(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; return __builtin_clzg(__x, _Nd); # 249 "/usr/include/c++/15/bit" 3 } template constexpr int __countl_one(_Tp __x) noexcept { return std::__countl_zero<_Tp>((_Tp)~__x); } template constexpr int __countr_zero(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; return __builtin_ctzg(__x, _Nd); # 294 "/usr/include/c++/15/bit" 3 } template constexpr int __countr_one(_Tp __x) noexcept { return std::__countr_zero((_Tp)~__x); } template constexpr int __popcount(_Tp __x) noexcept { return __builtin_popcountg(__x); # 334 "/usr/include/c++/15/bit" 3 } template constexpr bool __has_single_bit(_Tp __x) noexcept { return std::__popcount(__x) == 1; } template constexpr _Tp __bit_ceil(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; if (__x == 0 || __x == 1) return 1; auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); if (!std::__is_constant_evaluated()) { do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) std::__glibcxx_assert_fail(); } while (false); } using __promoted_type = decltype(__x << 1); if constexpr (!is_same<__promoted_type, _Tp>::value) { const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; } return (_Tp)1u << __shift_exponent; } template constexpr _Tp __bit_floor(_Tp __x) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; if (__x == 0) return 0; return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); } template constexpr int __bit_width(_Tp __x) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; return _Nd - std::__countl_zero(__x); } # 496 "/usr/include/c++/15/bit" 3 } # 77 "/usr/include/c++/15/bits/stl_algobase.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template constexpr inline int __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) { static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); # 109 "/usr/include/c++/15/bits/stl_algobase.h" 3 return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); } # 153 "/usr/include/c++/15/bits/stl_algobase.h" 3 template inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { # 186 "/usr/include/c++/15/bits/stl_algobase.h" 3 swap(*__a, *__b); } # 202 "/usr/include/c++/15/bits/stl_algobase.h" 3 template _ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { ; for (; __first1 != __last1; ++__first1, (void)++__first2) std::iter_swap(__first1, __first2); return __first2; } # 231 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] constexpr inline const _Tp& min(const _Tp& __a, const _Tp& __b) { if (__b < __a) return __b; return __a; } # 255 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] constexpr inline const _Tp& max(const _Tp& __a, const _Tp& __b) { if (__a < __b) return __b; return __a; } # 279 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] constexpr inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) { if (__comp(__b, __a)) return __b; return __a; } # 301 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] constexpr inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) { if (__comp(__a, __b)) return __b; return __a; } template struct _Deque_iterator; struct _Bit_iterator; template struct char_traits; template class istreambuf_iterator; template class ostreambuf_iterator; template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type __copy_move_a2(_CharT*, _CharT*, ostreambuf_iterator<_CharT, char_traits<_CharT> >); template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type __copy_move_a2(const _CharT*, const _CharT*, ostreambuf_iterator<_CharT, char_traits<_CharT> >); template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT*>::__type __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); template typename __gnu_cxx::__enable_if< __is_char<_CharT>::__value, std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type __copy_move_a2( istreambuf_iterator<_CharT, char_traits<_CharT> >, istreambuf_iterator<_CharT, char_traits<_CharT> >, std::_Deque_iterator<_CharT, _CharT&, _CharT*>); # 395 "/usr/include/c++/15/bits/stl_algobase.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template __attribute__((__always_inline__)) inline void __assign_one(_OutIter& __out, _InIter& __in) { if constexpr (_IsMove) *__out = std::move(*__in); else *__out = *__in; } template inline _OutIter __copy_move_a2(_InIter __first, _Sent __last, _OutIter __result) { typedef __decltype(*__first) _InRef; typedef __decltype(*__result) _OutRef; if constexpr (!__is_trivially_assignable(_OutRef, _InRef)) { } else if (std::__is_constant_evaluated()) { } else if constexpr (__memcpyable<_OutIter, _InIter>::__value) { ptrdiff_t __n = std::distance(__first, __last); if (__builtin_expect(__n > 1, true)) { __builtin_memmove(__result, __first, __n * sizeof(*__first)); __result += __n; } else if (__n == 1) { std::__assign_one<_IsMove>(__result, __first); ++__result; } return __result; } # 461 "/usr/include/c++/15/bits/stl_algobase.h" 3 for (; __first != __last; ++__result, (void)++__first) std::__assign_one<_IsMove>(__result, __first); return __result; } #pragma GCC diagnostic pop template _OI __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, std::_Deque_iterator<_Tp, _Ref, _Ptr>, _OI); template std::_Deque_iterator<_OTp, _OTp&, _OTp*> __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_OTp, _OTp&, _OTp*>); template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); template __attribute__((__always_inline__)) inline _OI __copy_move_a1(_II __first, _II __last, _OI __result) { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } template __attribute__((__always_inline__)) inline _OI __copy_move_a(_II __first, _II __last, _OI __result) { return std::__niter_wrap(__result, std::__copy_move_a1<_IsMove>(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); } template _OI __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, _OI); template __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> __copy_move_a(_II, _II, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); template ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template _OutputIterator __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, bool) { typedef __decltype(*__first) _InRef; typedef __decltype(*__result) _OutRef; if constexpr (!__is_trivially_assignable(_OutRef, _InRef)) { } else if constexpr (__memcpyable<_OutputIterator, _InputIterator>::__value) { if (__builtin_expect(__n > 1, true)) { __builtin_memmove(__result, __first, __n * sizeof(*__first)); __result += __n; } else if (__n == 1) *__result++ = *__first; return __result; } # 581 "/usr/include/c++/15/bits/stl_algobase.h" 3 if (__n > 0) { while (true) { *__result = *__first; ++__result; if (--__n > 0) ++__first; else break; } } return __result; } #pragma GCC diagnostic pop template typename __gnu_cxx::__enable_if< __is_char<_CharT>::__value, _CharT*>::__type __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, _CharT*, bool); template typename __gnu_cxx::__enable_if< __is_char<_CharT>::__value, std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, std::_Deque_iterator<_CharT, _CharT&, _CharT*>, bool); # 630 "/usr/include/c++/15/bits/stl_algobase.h" 3 template inline _OI copy(_II __first, _II __last, _OI __result) { ; return std::__copy_move_a<__is_move_iterator<_II>::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); } # 663 "/usr/include/c++/15/bits/stl_algobase.h" 3 template inline _OI move(_II __first, _II __last, _OI __result) { ; return std::__copy_move_a(std::__miter_base(__first), std::__miter_base(__last), __result); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline _BI2 __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) { typedef __decltype(*__first) _InRef; typedef __decltype(*__result) _OutRef; if constexpr (!__is_trivially_assignable(_OutRef, _InRef)) { } else if constexpr (__memcpyable<_BI2, _BI1>::__value) { ptrdiff_t __n = std::distance(__first, __last); std::advance(__result, -__n); if (__builtin_expect(__n > 1, true)) { __builtin_memmove(__result, __first, __n * sizeof(*__first)); } else if (__n == 1) std::__assign_one<_IsMove>(__result, __first); return __result; } # 735 "/usr/include/c++/15/bits/stl_algobase.h" 3 while (__first != __last) { --__last; --__result; std::__assign_one<_IsMove>(__result, __last); } return __result; } #pragma GCC diagnostic pop template __attribute__((__always_inline__)) inline _BI2 __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } template _OI __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, std::_Deque_iterator<_Tp, _Ref, _Ptr>, _OI); template std::_Deque_iterator<_OTp, _OTp&, _OTp*> __copy_move_backward_a1( std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_OTp, _OTp&, _OTp*>); template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __copy_move_backward_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); template __attribute__((__always_inline__)) inline _OI __copy_move_backward_a(_II __first, _II __last, _OI __result) { return std::__niter_wrap(__result, std::__copy_move_backward_a1<_IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); } template _OI __copy_move_backward_a( const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, _OI); template __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> __copy_move_backward_a(_II, _II, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); template ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> __copy_move_backward_a( const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); # 833 "/usr/include/c++/15/bits/stl_algobase.h" 3 template __attribute__((__always_inline__)) inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) { ; return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> (std::__miter_base(__first), std::__miter_base(__last), __result); } # 869 "/usr/include/c++/15/bits/stl_algobase.h" 3 template __attribute__((__always_inline__)) inline _BI2 move_backward(_BI1 __first, _BI1 __last, _BI2 __result) { ; return std::__copy_move_backward_a(std::__miter_base(__first), std::__miter_base(__last), __result); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline void __fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" const bool __load_outside_loop = __is_trivially_constructible(_Tp, const _Tp&) && __is_trivially_assignable(__decltype(*__first), const _Tp&) && sizeof(_Tp) <= sizeof(long long); #pragma GCC diagnostic pop typedef typename __gnu_cxx::__conditional_type<__load_outside_loop, const _Tp, const _Tp&>::__type _Up; _Up __val(__value); for (; __first != __last; ++__first) *__first = __val; } #pragma GCC diagnostic pop template inline typename __gnu_cxx::__enable_if<__is_byte<_Up>::__value && (__are_same<_Up, _Tp>::__value || __memcpyable_integer<_Tp>::__width), void>::__type __fill_a1(_Up* __first, _Up* __last, const _Tp& __x) { const _Up __val = __x; # 950 "/usr/include/c++/15/bits/stl_algobase.h" 3 if (const size_t __len = __last - __first) __builtin_memset(__first, static_cast(__val), __len); } template __attribute__((__always_inline__)) inline void __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, const _Tp& __value) { std::__fill_a1(__first.base(), __last.base(), __value); } template void __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, const _VTp&); void __fill_a1(std::_Bit_iterator, std::_Bit_iterator, const bool&); template __attribute__((__always_inline__)) inline void __fill_a(_FIte __first, _FIte __last, const _Tp& __value) { std::__fill_a1(__first, __last, __value); } template void __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const _Tp&); # 1000 "/usr/include/c++/15/bits/stl_algobase.h" 3 template __attribute__((__always_inline__)) inline void fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { ; std::__fill_a(__first, __last, __value); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" inline constexpr int __size_to_integer(int __n) { return __n; } inline constexpr unsigned __size_to_integer(unsigned __n) { return __n; } inline constexpr long __size_to_integer(long __n) { return __n; } inline constexpr unsigned long __size_to_integer(unsigned long __n) { return __n; } inline constexpr long long __size_to_integer(long long __n) { return __n; } inline constexpr unsigned long long __size_to_integer(unsigned long long __n) { return __n; } __extension__ inline constexpr __int128 __size_to_integer(__int128 __n) { return __n; } __extension__ inline constexpr unsigned __int128 __size_to_integer(unsigned __int128 __n) { return __n; } # 1055 "/usr/include/c++/15/bits/stl_algobase.h" 3 inline constexpr long long __size_to_integer(float __n) { return (long long)__n; } inline constexpr long long __size_to_integer(double __n) { return (long long)__n; } inline constexpr long long __size_to_integer(long double __n) { return (long long)__n; } #pragma GCC diagnostic pop #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" #pragma GCC diagnostic ignored "-Wlong-long" template inline _OutputIterator __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) { const bool __load_outside_loop = __is_trivially_constructible(_Tp, const _Tp&) && __is_trivially_assignable(__decltype(*__first), const _Tp&) && sizeof(_Tp) <= sizeof(long long); typedef typename __gnu_cxx::__conditional_type<__load_outside_loop, const _Tp, const _Tp&>::__type _Up; _Up __val(__value); for (; __n > 0; --__n, (void) ++__first) *__first = __val; return __first; } #pragma GCC diagnostic pop template ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, _Size __n, const _Tp& __value, std::input_iterator_tag); template __attribute__((__always_inline__)) inline _OutputIterator __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, std::output_iterator_tag) { static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); return __fill_n_a1(__first, __n, __value); } template __attribute__((__always_inline__)) inline _OutputIterator __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, std::input_iterator_tag) { static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); return __fill_n_a1(__first, __n, __value); } template __attribute__((__always_inline__)) inline _OutputIterator __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, std::random_access_iterator_tag) { static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); if (__n <= 0) return __first; ; std::__fill_a(__first, __first + __n, __value); return __first + __n; } # 1169 "/usr/include/c++/15/bits/stl_algobase.h" 3 template __attribute__((__always_inline__)) inline _OI fill_n(_OI __first, _Size __n, const _Tp& __value) { return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, std::__iterator_category(__first)); } template struct __equal { template static bool equal(_II1 __first1, _II1 __last1, _II2 __first2) { for (; __first1 != __last1; ++__first1, (void) ++__first2) if (!(*__first1 == *__first2)) return false; return true; } }; template<> struct __equal { template static bool equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) { if (const size_t __len = (__last1 - __first1)) return !std::__memcmp(__first1, __first2, __len); return true; } }; template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, bool>::__type __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, std::_Deque_iterator<_Tp, _Ref, _Ptr>, _II); template bool __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, bool>::__type __equal_aux1(_II, _II, std::_Deque_iterator<_Tp, _Ref, _Ptr>); template inline bool __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) { typedef typename iterator_traits<_II1>::value_type _ValueType1; const bool __simple = ((__is_integer<_ValueType1>::__value || __is_pointer(_ValueType1) || is_same_v<_ValueType1, byte> ) && __memcmpable<_II1, _II2>::__value); return std::__equal<__simple>::equal(__first1, __last1, __first2); } template __attribute__((__always_inline__)) inline bool __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) { return std::__equal_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2)); } template bool __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, _II2); template bool __equal_aux(_II1, _II1, const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); template bool __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); template struct __lc_rai { template static _II1 __newlast1(_II1, _II1 __last1, _II2, _II2) { return __last1; } template static bool __cnd2(_II __first, _II __last) { return __first != __last; } }; template<> struct __lc_rai { template static _RAI1 __newlast1(_RAI1 __first1, _RAI1 __last1, _RAI2 __first2, _RAI2 __last2) { const typename iterator_traits<_RAI1>::difference_type __diff1 = __last1 - __first1; const typename iterator_traits<_RAI2>::difference_type __diff2 = __last2 - __first2; return __diff2 < __diff1 ? __first1 + __diff2 : __last1; } template static bool __cnd2(_RAI, _RAI) { return true; } }; template bool __lexicographical_compare_impl(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp) { typedef typename iterator_traits<_II1>::iterator_category _Category1; typedef typename iterator_traits<_II2>::iterator_category _Category2; typedef std::__lc_rai<_Category1, _Category2> __rai_type; __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); ++__first1, (void)++__first2) { if (__comp(__first1, __first2)) return true; if (__comp(__first2, __first1)) return false; } return __first1 == __last1 && __first2 != __last2; } template struct __lexicographical_compare { template static bool __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { using __gnu_cxx::__ops::__iter_less_iter; return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __iter_less_iter()); } template static int __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { while (__first1 != __last1) { if (__first2 == __last2) return +1; if (*__first1 < *__first2) return -1; if (*__first2 < *__first1) return +1; ++__first1; ++__first2; } return int(__first2 == __last2) - 1; } }; template<> struct __lexicographical_compare { template static bool __lc(const _Tp* __first1, const _Tp* __last1, const _Up* __first2, const _Up* __last2) { return __3way(__first1, __last1, __first2, __last2) < 0; } template static ptrdiff_t __3way(const _Tp* __first1, const _Tp* __last1, const _Up* __first2, const _Up* __last2) { const size_t __len1 = __last1 - __first1; const size_t __len2 = __last2 - __first2; if (const size_t __len = std::min(__len1, __len2)) if (int __result = std::__memcmp(__first1, __first2, __len)) return __result; return ptrdiff_t(__len1 - __len2); } }; template inline bool __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { typedef typename iterator_traits<_II1>::value_type _ValueType1; typedef typename iterator_traits<_II2>::value_type _ValueType2; const bool __simple = (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value && __is_pointer(_II1) && __is_pointer(_II2) ); return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, __first2, __last2); } template bool __lexicographical_compare_aux1( std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, _Tp2*, _Tp2*); template bool __lexicographical_compare_aux1(_Tp1*, _Tp1*, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); template bool __lexicographical_compare_aux1( std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); template inline bool __lexicographical_compare_aux(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { return std::__lexicographical_compare_aux1(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2), std::__niter_base(__last2)); } template bool __lexicographical_compare_aux( const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, _II2, _II2); template bool __lexicographical_compare_aux( _II1, _II1, const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); template bool __lexicographical_compare_aux( const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); template _ForwardIterator __lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; _DistanceType __len = std::distance(__first, __last); while (__len > 0) { _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); if (__comp(__middle, __val)) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; } # 1532 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { ; return std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_less_val()); } template inline constexpr _Tp __lg(_Tp __n) { return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; # 1568 "/usr/include/c++/15/bits/stl_algobase.h" 3 } # 1584 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2) { ; return std::__equal_aux(__first1, __last1, __first2); } # 1615 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _BinaryPredicate __binary_pred) { ; for (; __first1 != __last1; ++__first1, (void)++__first2) if (!bool(__binary_pred(*__first1, *__first2))) return false; return true; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline bool __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { using _RATag = random_access_iterator_tag; using _Cat1 = typename iterator_traits<_II1>::iterator_category; using _Cat2 = typename iterator_traits<_II2>::iterator_category; using _RAIters = __and_, is_same<_Cat2, _RATag>>; if constexpr (_RAIters::value) { if ((__last1 - __first1) != (__last2 - __first2)) return false; return std::equal(__first1, __last1, __first2); } else { for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) if (!(*__first1 == *__first2)) return false; return __first1 == __last1 && __first2 == __last2; } } template inline bool __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _BinaryPredicate __binary_pred) { using _RATag = random_access_iterator_tag; using _Cat1 = typename iterator_traits<_II1>::iterator_category; using _Cat2 = typename iterator_traits<_II2>::iterator_category; using _RAIters = __and_, is_same<_Cat2, _RATag>>; if constexpr (_RAIters::value) { if ((__last1 - __first1) != (__last2 - __first2)) return false; return std::equal(__first1, __last1, __first2, __binary_pred); } else { for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) if (!bool(__binary_pred(*__first1, *__first2))) return false; return __first1 == __last1 && __first2 == __last2; } } #pragma GCC diagnostic pop # 1706 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { ; ; return std::__equal4(__first1, __last1, __first2, __last2); } # 1739 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) { ; ; return std::__equal4(__first1, __last1, __first2, __last2, __binary_pred); } # 1771 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { ; ; return std::__lexicographical_compare_aux(__first1, __last1, __first2, __last2); } # 1806 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp) { ; ; return std::__lexicographical_compare_impl (__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 1921 "/usr/include/c++/15/bits/stl_algobase.h" 3 template pair<_InputIterator1, _InputIterator2> __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) { while (__first1 != __last1 && __binary_pred(__first1, __first2)) { ++__first1; ++__first2; } return pair<_InputIterator1, _InputIterator2>(__first1, __first2); } # 1949 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { ; return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 1983 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) { ; return std::__mismatch(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); } template pair<_InputIterator1, _InputIterator2> __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __binary_pred) { while (__first1 != __last1 && __first2 != __last2 && __binary_pred(__first1, __first2)) { ++__first1; ++__first2; } return pair<_InputIterator1, _InputIterator2>(__first1, __first2); } # 2031 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { ; ; return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 2067 "/usr/include/c++/15/bits/stl_algobase.h" 3 template [[__nodiscard__]] inline pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __binary_pred) { ; ; return std::__mismatch(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); } template inline _Iterator __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) { #pragma GCC unroll 4 while (__first != __last && !__pred(__first)) ++__first; return __first; } template typename iterator_traits<_InputIterator>::difference_type __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { typename iterator_traits<_InputIterator>::difference_type __n = 0; for (; __first != __last; ++__first) if (__pred(__first)) ++__n; return __n; } template _ForwardIterator __remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { __first = std::__find_if(__first, __last, __pred); if (__first == __last) return __first; _ForwardIterator __result = __first; ++__first; for (; __first != __last; ++__first) if (!__pred(__first)) { *__result = std::move(*__first); ++__result; } return __result; } template _ForwardIterator1 __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __predicate) { if (__first1 == __last1 || __first2 == __last2) return __first1; _ForwardIterator2 __p1(__first2); if (++__p1 == __last2) return std::__find_if(__first1, __last1, __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); _ForwardIterator1 __current = __first1; for (;;) { __first1 = std::__find_if(__first1, __last1, __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); if (__first1 == __last1) return __last1; _ForwardIterator2 __p = __p1; __current = __first1; if (++__current == __last1) return __last1; while (__predicate(__current, __p)) { if (++__p == __last2) return __first1; if (++__current == __last1) return __last1; } ++__first1; } return __first1; } template bool __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred) { for (; __first1 != __last1; ++__first1, (void)++__first2) if (!__pred(__first1, __first2)) break; if (__first1 == __last1) return true; _ForwardIterator2 __last2 = __first2; std::advance(__last2, std::distance(__first1, __last1)); for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) { if (__scan != std::__find_if(__first1, __scan, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) continue; auto __matches = std::__count_if(__first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); if (0 == __matches || std::__count_if(__scan, __last1, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) != __matches) return false; } return true; } # 2230 "/usr/include/c++/15/bits/stl_algobase.h" 3 template inline bool is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { ; return std::__is_permutation(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 2272 "/usr/include/c++/15/bits/stl_algobase.h" 3 template inline _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __predicate) { ; ; return std::__search(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__predicate)); } } # 37 "/usr/include/c++/15/bits/hashtable_policy.h" 2 3 # 1 "/usr/include/c++/15/ext/aligned_buffer.h" 1 3 # 42 "/usr/include/c++/15/ext/aligned_buffer.h" 3 namespace __gnu_cxx { template struct __aligned_membuf { # 60 "/usr/include/c++/15/ext/aligned_buffer.h" 3 alignas(_Tp) unsigned char _M_storage[sizeof(_Tp)]; __aligned_membuf() = default; __aligned_membuf(std::nullptr_t) { } void* _M_addr() noexcept { return static_cast(&_M_storage); } const void* _M_addr() const noexcept { return static_cast(&_M_storage); } _Tp* _M_ptr() noexcept { return static_cast<_Tp*>(_M_addr()); } const _Tp* _M_ptr() const noexcept { return static_cast(_M_addr()); } }; # 95 "/usr/include/c++/15/ext/aligned_buffer.h" 3 template struct __aligned_buffer { alignas(__alignof__(_Tp)) unsigned char _M_storage[sizeof(_Tp)]; __aligned_buffer() = default; __aligned_buffer(std::nullptr_t) { } void* _M_addr() noexcept { return static_cast(&_M_storage); } const void* _M_addr() const noexcept { return static_cast(&_M_storage); } _Tp* _M_ptr() noexcept { return static_cast<_Tp*>(_M_addr()); } const _Tp* _M_ptr() const noexcept { return static_cast(_M_addr()); } }; } # 39 "/usr/include/c++/15/bits/hashtable_policy.h" 2 3 # 1 "/usr/include/c++/15/ext/alloc_traits.h" 1 3 # 36 "/usr/include/c++/15/ext/alloc_traits.h" 3 # 1 "/usr/include/c++/15/bits/alloc_traits.h" 1 3 # 33 "/usr/include/c++/15/bits/alloc_traits.h" 3 # 1 "/usr/include/c++/15/bits/stl_construct.h" 1 3 # 73 "/usr/include/c++/15/bits/stl_construct.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline void destroy_at(_Tp* __location) { if constexpr (201703L > 201703L && is_array_v<_Tp>) { for (auto& __x : *__location) std::destroy_at(std::__addressof(__x)); } else __location->~_Tp(); } # 120 "/usr/include/c++/15/bits/stl_construct.h" 3 template inline void _Construct(_Tp* __p, _Args&&... __args) { # 133 "/usr/include/c++/15/bits/stl_construct.h" 3 ::new(static_cast(__p)) _Tp(std::forward<_Args>(__args)...); } # 146 "/usr/include/c++/15/bits/stl_construct.h" 3 template inline void _Construct_novalue(_T1* __p) { ::new(static_cast(__p)) _T1; } template void _Destroy(_ForwardIterator __first, _ForwardIterator __last); template constexpr inline void _Destroy(_Tp* __pointer) { __pointer->~_Tp(); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" # 217 "/usr/include/c++/15/bits/stl_construct.h" 3 template inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _Value_type; if constexpr (!is_trivially_destructible<_Value_type>::value) for (; __first != __last; ++__first) std::_Destroy(std::__addressof(*__first)); # 236 "/usr/include/c++/15/bits/stl_construct.h" 3 } template inline _ForwardIterator _Destroy_n(_ForwardIterator __first, _Size __count) { typedef typename iterator_traits<_ForwardIterator>::value_type _Value_type; if constexpr (!is_trivially_destructible<_Value_type>::value) for (; __count > 0; (void)++__first, --__count) std::_Destroy(std::__addressof(*__first)); else std::advance(__first, __count); return __first; } #pragma GCC diagnostic pop template inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { std::_Destroy(__first, __last); } template inline _ForwardIterator destroy_n(_ForwardIterator __first, _Size __count) { return std::_Destroy_n(__first, __count); } } # 34 "/usr/include/c++/15/bits/alloc_traits.h" 2 3 # 1 "/usr/include/c++/15/bits/memoryfwd.h" 1 3 # 52 "/usr/include/c++/15/bits/memoryfwd.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 66 "/usr/include/c++/15/bits/memoryfwd.h" 3 template class allocator; template<> class allocator; template struct uses_allocator; template struct allocator_traits; } # 35 "/usr/include/c++/15/bits/alloc_traits.h" 2 3 # 1 "/usr/include/c++/15/bits/allocator.h" 1 3 # 46 "/usr/include/c++/15/bits/allocator.h" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++allocator.h" 1 3 # 33 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++allocator.h" 3 # 1 "/usr/include/c++/15/bits/new_allocator.h" 1 3 # 41 "/usr/include/c++/15/bits/new_allocator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 62 "/usr/include/c++/15/bits/new_allocator.h" 3 template class __new_allocator { public: typedef _Tp value_type; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef _Tp* pointer; typedef const _Tp* const_pointer; typedef _Tp& reference; typedef const _Tp& const_reference; template struct rebind { typedef __new_allocator<_Tp1> other; }; typedef std::true_type propagate_on_container_move_assignment; __attribute__((__always_inline__)) __new_allocator() noexcept { } __attribute__((__always_inline__)) __new_allocator(const __new_allocator&) noexcept { } template __attribute__((__always_inline__)) __new_allocator(const __new_allocator<_Tp1>&) noexcept { } __new_allocator& operator=(const __new_allocator&) = default; ~__new_allocator() noexcept { } pointer address(reference __x) const noexcept { return std::__addressof(__x); } const_pointer address(const_reference __x) const noexcept { return std::__addressof(__x); } # 125 "/usr/include/c++/15/bits/new_allocator.h" 3 [[__nodiscard__]] _Tp* allocate(size_type __n, const void* = static_cast(0)) { static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); if (__builtin_expect(__n > this->_M_max_size(), false)) { if (__n > (std::size_t(-1) / sizeof(_Tp))) std::__throw_bad_array_new_length(); std::__throw_bad_alloc(); } if (alignof(_Tp) > 16) { std::align_val_t __al = std::align_val_t(alignof(_Tp)); return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), __al)); } return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); } void deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) { if (alignof(_Tp) > 16) { __builtin_operator_delete((__p), (__n) * sizeof(_Tp), std::align_val_t(alignof(_Tp))); return; } __builtin_operator_delete((__p), (__n) * sizeof(_Tp)); } __attribute__((__always_inline__)) size_type max_size() const noexcept { return _M_max_size(); } template __attribute__((__always_inline__)) void construct(_Up* __p, _Args&&... __args) noexcept(__is_nothrow_new_constructible<_Up, _Args...>) { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } template __attribute__((__always_inline__)) void destroy(_Up* __p) noexcept(std::is_nothrow_destructible<_Up>::value) { __p->~_Up(); } # 213 "/usr/include/c++/15/bits/new_allocator.h" 3 template friend __attribute__((__always_inline__)) bool operator==(const __new_allocator&, const __new_allocator<_Up>&) noexcept { return true; } template friend __attribute__((__always_inline__)) bool operator!=(const __new_allocator&, const __new_allocator<_Up>&) noexcept { return false; } private: __attribute__((__always_inline__)) constexpr size_type _M_max_size() const noexcept { return std::size_t(0x7fffffffffffffffL) / sizeof(_Tp); } }; } # 34 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++allocator.h" 2 3 namespace std { # 46 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++allocator.h" 3 template using __allocator_base = __new_allocator<_Tp>; } # 47 "/usr/include/c++/15/bits/allocator.h" 2 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { # 75 "/usr/include/c++/15/bits/allocator.h" 3 template<> class allocator { public: typedef void value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; template struct rebind { typedef allocator<_Tp1> other; }; using propagate_on_container_move_assignment = true_type; using is_always_equal = true_type; # 120 "/usr/include/c++/15/bits/allocator.h" 3 }; # 132 "/usr/include/c++/15/bits/allocator.h" 3 template class allocator : public __allocator_base<_Tp> { public: typedef _Tp value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef const _Tp* const_pointer; typedef _Tp& reference; typedef const _Tp& const_reference; template struct rebind { typedef allocator<_Tp1> other; }; using propagate_on_container_move_assignment = true_type; using is_always_equal = true_type; __attribute__((__always_inline__)) allocator() noexcept { } __attribute__((__always_inline__)) allocator(const allocator& __a) noexcept : __allocator_base<_Tp>(__a) { } allocator& operator=(const allocator&) = default; template __attribute__((__always_inline__)) allocator(const allocator<_Tp1>&) noexcept { } __attribute__((__always_inline__)) ~allocator() noexcept { } # 219 "/usr/include/c++/15/bits/allocator.h" 3 friend __attribute__((__always_inline__)) bool operator==(const allocator&, const allocator&) noexcept { return true; } friend __attribute__((__always_inline__)) bool operator!=(const allocator&, const allocator&) noexcept { return false; } }; template __attribute__((__always_inline__)) inline bool operator==(const allocator<_T1>&, const allocator<_T2>&) noexcept { return true; } template __attribute__((__always_inline__)) inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&) noexcept { return false; } template class allocator { public: typedef _Tp value_type; allocator() { } template allocator(const allocator<_Up>&) { } }; template class allocator { public: typedef _Tp value_type; allocator() { } template allocator(const allocator<_Up>&) { } }; template class allocator { public: typedef _Tp value_type; allocator() { } template allocator(const allocator<_Up>&) { } }; extern template class allocator; extern template class allocator; } #pragma GCC diagnostic pop # 40 "/usr/include/c++/15/bits/alloc_traits.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 52 "/usr/include/c++/15/bits/alloc_traits.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++14-extensions" #pragma GCC diagnostic ignored "-Wc++17-extensions" struct __allocator_traits_base { template struct __rebind : __replace_first_arg<_Tp, _Up> { static_assert(is_same< typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, _Tp>::value, "allocator_traits::rebind_alloc must be A"); }; template struct __rebind<_Tp, _Up, __void_t::other>> { using type = typename _Tp::template rebind<_Up>::other; static_assert(is_same< typename _Tp::template rebind::other, _Tp>::value, "allocator_traits::rebind_alloc must be A"); }; protected: template using __pointer = typename _Tp::pointer; template using __c_pointer = typename _Tp::const_pointer; template using __v_pointer = typename _Tp::void_pointer; template using __cv_pointer = typename _Tp::const_void_pointer; template using __pocca = typename _Tp::propagate_on_container_copy_assignment; template using __pocma = typename _Tp::propagate_on_container_move_assignment; template using __pocs = typename _Tp::propagate_on_container_swap; template using __equal = __type_identity; # 115 "/usr/include/c++/15/bits/alloc_traits.h" 3 template using __allocate_hint_t = decltype(std::declval<_Alloc&>() .allocate(std::declval<_Sz>(), std::declval<_Vp>())); template static constexpr bool __has_allocate_hint = false; template static constexpr bool __has_allocate_hint<_Alloc, _Sz, _Vp, __void_t<__allocate_hint_t<_Alloc, _Sz, _Vp>>> = true; # 152 "/usr/include/c++/15/bits/alloc_traits.h" 3 template using __construct_t = decltype(std::declval<_Alloc&>().construct(std::declval<_Tp*>(), std::declval<_Args>()...)); template static constexpr bool __has_construct_impl = false; template static constexpr bool __has_construct_impl<_Alloc, _Tp, __void_t<__construct_t<_Alloc, _Tp, _Args...>>, _Args...> = true; template static constexpr bool __has_construct = __has_construct_impl<_Alloc, _Tp, void, _Args...>; template using __new_expr_t = decltype(::new((void*)0) _Tp(std::declval<_Args>()...)); template static constexpr bool __has_new_expr = false; template static constexpr bool __has_new_expr<_Tp, __void_t<__new_expr_t<_Tp, _Args...>>, _Args...> = true; template static constexpr bool __can_construct = __has_construct<_Alloc, _Tp, _Args...> || __has_new_expr<_Tp, void, _Args...>; # 189 "/usr/include/c++/15/bits/alloc_traits.h" 3 template using __destroy_t = decltype(std::declval<_Alloc&>().destroy(std::declval<_Tp*>())); template static constexpr bool __has_destroy = false; template static constexpr bool __has_destroy<_Alloc, _Tp, __void_t<__destroy_t<_Alloc, _Tp>>> = true; # 207 "/usr/include/c++/15/bits/alloc_traits.h" 3 template using __max_size_t = decltype(std::declval().max_size()); template static constexpr bool __has_max_size = false; template static constexpr bool __has_max_size<_Alloc, __void_t<__max_size_t<_Alloc>>> = true; # 225 "/usr/include/c++/15/bits/alloc_traits.h" 3 template using __soccc_t = decltype(std::declval() .select_on_container_copy_construction()); template static constexpr bool __has_soccc = false; template static constexpr bool __has_soccc<_Alloc, __void_t<__soccc_t<_Alloc>>> = true; }; template using __alloc_rebind = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; # 248 "/usr/include/c++/15/bits/alloc_traits.h" 3 template struct allocator_traits : __allocator_traits_base { typedef _Alloc allocator_type; typedef typename _Alloc::value_type value_type; using pointer = __detected_or_t; private: template class _Func, typename _Tp, typename = void> struct _Ptr { using type = typename pointer_traits::template rebind<_Tp>; }; template class _Func, typename _Tp> struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> { using type = _Func<_Alloc>; }; template struct _Diff { using type = typename pointer_traits<_PtrT>::difference_type; }; template struct _Diff<_A2, _PtrT, __void_t> { using type = typename _A2::difference_type; }; template struct _Size : make_unsigned<_DiffT> { }; template struct _Size<_A2, _DiffT, __void_t> { using type = typename _A2::size_type; }; public: using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; using void_pointer = typename _Ptr<__v_pointer, void>::type; using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; using difference_type = typename _Diff<_Alloc, pointer>::type; using size_type = typename _Size<_Alloc, difference_type>::type; using propagate_on_container_copy_assignment = __detected_or_t; using propagate_on_container_move_assignment = __detected_or_t; using propagate_on_container_swap = __detected_or_t; using is_always_equal = typename __detected_or_t, __equal, _Alloc>::type; template using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; template using rebind_traits = allocator_traits>; # 383 "/usr/include/c++/15/bits/alloc_traits.h" 3 [[__nodiscard__]] static pointer allocate(_Alloc& __a, size_type __n) { return __a.allocate(__n); } # 398 "/usr/include/c++/15/bits/alloc_traits.h" 3 [[__nodiscard__]] static pointer allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) { if constexpr (__has_allocate_hint<_Alloc, size_type, const_void_pointer>) return __a.allocate(__n, __hint); else return __a.allocate(__n); } # 415 "/usr/include/c++/15/bits/alloc_traits.h" 3 static void deallocate(_Alloc& __a, pointer __p, size_type __n) { __a.deallocate(__p, __n); } # 430 "/usr/include/c++/15/bits/alloc_traits.h" 3 template static __enable_if_t<__can_construct<_Alloc, _Tp, _Args...>> construct(_Alloc& __a, _Tp* __p, _Args&&... __args) noexcept(_S_nothrow_construct<_Tp, _Args...>()) { if constexpr (__has_construct<_Alloc, _Tp, _Args...>) __a.construct(__p, std::forward<_Args>(__args)...); else std::_Construct(__p, std::forward<_Args>(__args)...); } # 454 "/usr/include/c++/15/bits/alloc_traits.h" 3 template static void destroy(_Alloc& __a, _Tp* __p) noexcept(_S_nothrow_destroy<_Tp>()) { if constexpr (__has_destroy<_Alloc, _Tp>) __a.destroy(__p); else std::_Destroy(__p); } # 473 "/usr/include/c++/15/bits/alloc_traits.h" 3 static size_type max_size(const _Alloc& __a) noexcept { if constexpr (__has_max_size<_Alloc>) return __a.max_size(); else return __gnu_cxx::__numeric_traits::__max / sizeof(value_type); } # 493 "/usr/include/c++/15/bits/alloc_traits.h" 3 static _Alloc select_on_container_copy_construction(const _Alloc& __rhs) { if constexpr (__has_soccc<_Alloc>) return __rhs.select_on_container_copy_construction(); else return __rhs; } private: template static constexpr bool _S_nothrow_construct(_Alloc* __a = nullptr, _Tp* __p = nullptr) { if constexpr (__has_construct<_Alloc, _Tp, _Args...>) return noexcept(__a->construct(__p, std::declval<_Args>()...)); else return __is_nothrow_new_constructible<_Tp, _Args...>; } template static constexpr bool _S_nothrow_destroy(_Alloc* __a = nullptr, _Tp* __p = nullptr) { if constexpr (__has_destroy<_Alloc, _Tp>) return noexcept(__a->destroy(__p)); else return is_nothrow_destructible<_Tp>::value; } # 548 "/usr/include/c++/15/bits/alloc_traits.h" 3 }; #pragma GCC diagnostic pop # 559 "/usr/include/c++/15/bits/alloc_traits.h" 3 template struct allocator_traits> { using allocator_type = allocator<_Tp>; using value_type = _Tp; using pointer = _Tp*; using const_pointer = const _Tp*; using void_pointer = void*; using const_void_pointer = const void*; using difference_type = std::ptrdiff_t; using size_type = std::size_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 using rebind_alloc = allocator<_Up>; template using rebind_traits = allocator_traits>; # 611 "/usr/include/c++/15/bits/alloc_traits.h" 3 [[__nodiscard__,__gnu__::__always_inline__]] static pointer allocate(allocator_type& __a, size_type __n) { return __a.allocate(__n); } # 626 "/usr/include/c++/15/bits/alloc_traits.h" 3 [[__nodiscard__,__gnu__::__always_inline__]] static pointer allocate(allocator_type& __a, size_type __n, [[maybe_unused]] const_void_pointer __hint) { return __a.allocate(__n, __hint); } # 646 "/usr/include/c++/15/bits/alloc_traits.h" 3 [[__gnu__::__always_inline__]] static void deallocate(allocator_type& __a, pointer __p, size_type __n) { __a.deallocate(__p, __n); } # 662 "/usr/include/c++/15/bits/alloc_traits.h" 3 template [[__gnu__::__always_inline__]] static void construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, _Args&&... __args) noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) { __a.construct(__p, std::forward<_Args>(__args)...); } # 689 "/usr/include/c++/15/bits/alloc_traits.h" 3 template [[__gnu__::__always_inline__]] static void destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) noexcept(is_nothrow_destructible<_Up>::value) { __a.destroy(__p); } [[__gnu__::__always_inline__]] static size_type max_size(const allocator_type& __a __attribute__((__unused__))) noexcept { return __a.max_size(); } [[__gnu__::__always_inline__]] static allocator_type select_on_container_copy_construction(const allocator_type& __rhs) { return __rhs; } }; # 736 "/usr/include/c++/15/bits/alloc_traits.h" 3 template<> struct allocator_traits> { using allocator_type = allocator; using value_type = void; using pointer = void*; using const_pointer = const void*; using void_pointer = void*; using const_void_pointer = const void*; using difference_type = std::ptrdiff_t; using size_type = std::size_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 using rebind_alloc = allocator<_Up>; template using rebind_traits = allocator_traits>; static void* allocate(allocator_type&, size_type, const void* = nullptr) = delete; static void deallocate(allocator_type&, void*, size_type) = delete; # 800 "/usr/include/c++/15/bits/alloc_traits.h" 3 template [[__gnu__::__always_inline__]] static void construct(allocator_type&, _Up* __p, _Args&&... __args) noexcept(__is_nothrow_new_constructible<_Up, _Args...>) { std::_Construct(__p, std::forward<_Args>(__args)...); } # 814 "/usr/include/c++/15/bits/alloc_traits.h" 3 template [[__gnu__::__always_inline__]] static void destroy(allocator_type&, _Up* __p) noexcept(is_nothrow_destructible<_Up>::value) { std::_Destroy(__p); } static size_type max_size(const allocator_type&) = delete; [[__gnu__::__always_inline__]] static allocator_type select_on_container_copy_construction(const allocator_type& __rhs) { return __rhs; } }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template [[__gnu__::__always_inline__]] constexpr inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two) { using __traits = allocator_traits<_Alloc>; using __pocca = typename __traits::propagate_on_container_copy_assignment::type; if constexpr (__pocca::value) __one = __two; } template [[__gnu__::__always_inline__]] constexpr _Alloc __alloc_on_copy(const _Alloc& __a) { typedef allocator_traits<_Alloc> __traits; return __traits::select_on_container_copy_construction(__a); } template [[__gnu__::__always_inline__]] constexpr inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) { using __traits = allocator_traits<_Alloc>; using __pocma = typename __traits::propagate_on_container_move_assignment::type; if constexpr (__pocma::value) __one = std::move(__two); } template [[__gnu__::__always_inline__]] constexpr inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two) { using __traits = allocator_traits<_Alloc>; using __pocs = typename __traits::propagate_on_container_swap::type; if constexpr (__pocs::value) { using std::swap; swap(__one, __two); } } #pragma GCC diagnostic pop template, typename = void> struct __is_alloc_insertable_impl : false_type { }; template struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, __void_t::construct( std::declval<_Alloc&>(), std::declval<_ValueT*>(), std::declval<_Tp>()))>> : true_type { }; template struct __is_copy_insertable : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type const&>::type { }; template struct __is_copy_insertable> : is_copy_constructible<_Tp> { }; template struct __is_move_insertable : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type { }; template struct __is_move_insertable> : is_move_constructible<_Tp> { }; template struct __is_allocator : false_type { }; template struct __is_allocator<_Alloc, __void_t().allocate(size_t{}))>> : true_type { }; template using _RequireAllocator = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; template using _RequireNotAllocator = typename enable_if::value, _Alloc>::type; # 970 "/usr/include/c++/15/bits/alloc_traits.h" 3 template struct __alloc_swap { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; template struct __alloc_swap<_Alloc, false> { static void _S_do_it(_Alloc& __one, _Alloc& __two) noexcept { if (__one != __two) swap(__one, __two); } }; template, is_nothrow_move_constructible>::value> struct __shrink_to_fit_aux { static bool _S_do_it(_Tp&) noexcept { return false; } }; template struct __shrink_to_fit_aux<_Tp, true> { static bool _S_do_it(_Tp& __c) noexcept { try { _Tp(__make_move_if_noexcept_iterator(__c.begin()), __make_move_if_noexcept_iterator(__c.end()), __c.get_allocator()).swap(__c); return true; } catch(...) { return false; } } }; # 1023 "/usr/include/c++/15/bits/alloc_traits.h" 3 template void _Destroy(_ForwardIterator __first, _ForwardIterator __last, _Allocator& __alloc) { for (; __first != __last; ++__first) allocator_traits<_Allocator>::destroy(__alloc, std::__addressof(*__first)); } template __attribute__((__always_inline__)) inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last, allocator<_Tp>&) { std::_Destroy(__first, __last); } } # 37 "/usr/include/c++/15/ext/alloc_traits.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template struct __alloc_traits : std::allocator_traits<_Alloc> { typedef _Alloc allocator_type; typedef std::allocator_traits<_Alloc> _Base_type; typedef typename _Base_type::value_type value_type; typedef typename _Base_type::pointer pointer; typedef typename _Base_type::const_pointer const_pointer; typedef typename _Base_type::size_type size_type; typedef typename _Base_type::difference_type difference_type; typedef value_type& reference; typedef const value_type& const_reference; using _Base_type::allocate; using _Base_type::deallocate; using _Base_type::construct; using _Base_type::destroy; using _Base_type::max_size; private: template using __is_custom_pointer = std::__and_, std::__not_>>; public: template [[__gnu__::__always_inline__]] static constexpr std::__enable_if_t<__is_custom_pointer<_Ptr>::value> construct(_Alloc& __a, _Ptr __p, _Args&&... __args) noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), std::forward<_Args>(__args)...))) { _Base_type::construct(__a, std::__to_address(__p), std::forward<_Args>(__args)...); } template [[__gnu__::__always_inline__]] static constexpr std::__enable_if_t<__is_custom_pointer<_Ptr>::value> destroy(_Alloc& __a, _Ptr __p) noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) { _Base_type::destroy(__a, std::__to_address(__p)); } [[__gnu__::__always_inline__]] static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) { return _Base_type::select_on_container_copy_construction(__a); } [[__gnu__::__always_inline__]] static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) { std::__alloc_on_swap(__a, __b); } [[__gnu__::__always_inline__]] static constexpr bool _S_propagate_on_copy_assign() { return _Base_type::propagate_on_container_copy_assignment::value; } [[__gnu__::__always_inline__]] static constexpr bool _S_propagate_on_move_assign() { return _Base_type::propagate_on_container_move_assignment::value; } [[__gnu__::__always_inline__]] static constexpr bool _S_propagate_on_swap() { return _Base_type::propagate_on_container_swap::value; } [[__gnu__::__always_inline__]] static constexpr bool _S_always_equal() { return _Base_type::is_always_equal::value; } __attribute__((__always_inline__)) static constexpr bool _S_nothrow_move() { return _S_propagate_on_move_assign() || _S_always_equal(); } template struct rebind { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; # 182 "/usr/include/c++/15/ext/alloc_traits.h" 3 }; } # 40 "/usr/include/c++/15/bits/hashtable_policy.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class _Hashtable; namespace __detail { template struct _Hashtable_base; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last) { using _Cat = typename std::iterator_traits<_Iterator>::iterator_category; if constexpr (is_convertible<_Cat, forward_iterator_tag>::value) return std::distance(__first, __last); else return __first != __last ? 1 : 0; } #pragma GCC diagnostic pop struct _Identity { template _Tp&& operator()(_Tp&& __x) const noexcept { return std::forward<_Tp>(__x); } }; struct _Select1st { template struct __1st_type; template struct __1st_type> { using type = _Tp; }; template struct __1st_type> { using type = const _Tp; }; template struct __1st_type<_Pair&> { using type = typename __1st_type<_Pair>::type&; }; template typename __1st_type<_Tp>::type&& operator()(_Tp&& __x) const noexcept { return std::forward<_Tp>(__x).first; } }; template struct _NodeBuilder; template<> struct _NodeBuilder<_Select1st> { template static auto _S_build(_Kt&& __k, _Arg&& __arg, _NodeGenerator& __node_gen) -> typename _NodeGenerator::__node_ptr { return __node_gen(std::forward<_Kt>(__k), std::forward<_Arg>(__arg).second); } }; template<> struct _NodeBuilder<_Identity> { template static auto _S_build(_Kt&& __k, _Arg&&, _NodeGenerator& __node_gen) -> typename _NodeGenerator::__node_ptr { return __node_gen(std::forward<_Kt>(__k)); } }; template struct _NodePtrGuard { _HashtableAlloc& _M_h; _NodePtr _M_ptr; ~_NodePtrGuard() { if (_M_ptr) _M_h._M_deallocate_node_ptr(_M_ptr); } }; template struct _Hashtable_alloc; template struct _ReuseOrAllocNode { private: using __node_alloc_type = _NodeAlloc; using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>; using __node_alloc_traits = typename __hashtable_alloc::__node_alloc_traits; public: using __node_ptr = typename __hashtable_alloc::__node_ptr; _ReuseOrAllocNode(__node_ptr __nodes, __hashtable_alloc& __h) : _M_nodes(__nodes), _M_h(__h) { } _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; ~_ReuseOrAllocNode() { _M_h._M_deallocate_nodes(_M_nodes); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template __node_ptr operator()(_Arg&& __arg) { if (!_M_nodes) return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); using value_type = typename _NodeAlloc::value_type::value_type; __node_ptr __node = _M_nodes; if constexpr (is_assignable::value) { __node->_M_v() = std::forward<_Arg>(__arg); _M_nodes = _M_nodes->_M_next(); __node->_M_nxt = nullptr; } else { _M_nodes = _M_nodes->_M_next(); __node->_M_nxt = nullptr; auto& __a = _M_h._M_node_allocator(); __node_alloc_traits::destroy(__a, __node->_M_valptr()); _NodePtrGuard<__hashtable_alloc, __node_ptr> __guard{ _M_h, __node }; __node_alloc_traits::construct(__a, __node->_M_valptr(), std::forward<_Arg>(__arg)); __guard._M_ptr = nullptr; } return __node; } #pragma GCC diagnostic pop private: __node_ptr _M_nodes; __hashtable_alloc& _M_h; }; template struct _AllocNode { private: using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>; public: using __node_ptr = typename __hashtable_alloc::__node_ptr; _AllocNode(__hashtable_alloc& __h) : _M_h(__h) { } template __node_ptr operator()(_Args&&... __args) const { return _M_h._M_allocate_node(std::forward<_Args>(__args)...); } private: __hashtable_alloc& _M_h; }; # 262 "/usr/include/c++/15/bits/hashtable_policy.h" 3 template struct _Hashtable_traits { using __hash_cached = __bool_constant<_Cache_hash_code>; using __constant_iterators = __bool_constant<_Constant_iterators>; using __unique_keys = __bool_constant<_Unique_keys>; }; template struct _Hashtable_hash_traits { static constexpr size_t __small_size_threshold() noexcept { return std::__is_fast_hash<_Hash>::value ? 0 : 20; } }; # 292 "/usr/include/c++/15/bits/hashtable_policy.h" 3 struct _Hash_node_base { _Hash_node_base* _M_nxt; _Hash_node_base() noexcept : _M_nxt() { } _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { } }; template struct _Hash_node_value_base { using value_type = _Value; __gnu_cxx::__aligned_buffer<_Value> _M_storage; [[__gnu__::__always_inline__]] _Value* _M_valptr() noexcept { return _M_storage._M_ptr(); } [[__gnu__::__always_inline__]] const _Value* _M_valptr() const noexcept { return _M_storage._M_ptr(); } [[__gnu__::__always_inline__]] _Value& _M_v() noexcept { return *_M_valptr(); } [[__gnu__::__always_inline__]] const _Value& _M_v() const noexcept { return *_M_valptr(); } }; template struct _Hash_node_code_cache { }; template<> struct _Hash_node_code_cache { size_t _M_hash_code; }; template struct _Hash_node_value : _Hash_node_value_base<_Value> , _Hash_node_code_cache<_Cache_hash_code> { }; template struct _Hash_node : _Hash_node_base , _Hash_node_value<_Value, _Cache_hash_code> { _Hash_node* _M_next() const noexcept { return static_cast<_Hash_node*>(this->_M_nxt); } }; template struct _Node_iterator_base { using __node_type = _Hash_node<_Value, _Cache_hash_code>; __node_type* _M_cur; _Node_iterator_base() : _M_cur(nullptr) { } _Node_iterator_base(__node_type* __p) noexcept : _M_cur(__p) { } void _M_incr() noexcept { _M_cur = _M_cur->_M_next(); } friend bool operator==(const _Node_iterator_base& __x, const _Node_iterator_base& __y) noexcept { return __x._M_cur == __y._M_cur; } friend bool operator!=(const _Node_iterator_base& __x, const _Node_iterator_base& __y) noexcept { return __x._M_cur != __y._M_cur; } }; template struct _Node_iterator : public _Node_iterator_base<_Value, __cache> { private: using __base_type = _Node_iterator_base<_Value, __cache>; using __node_type = typename __base_type::__node_type; public: using value_type = _Value; using difference_type = ptrdiff_t; using iterator_category = forward_iterator_tag; using pointer = __conditional_t<__constant_iterators, const value_type*, value_type*>; using reference = __conditional_t<__constant_iterators, const value_type&, value_type&>; _Node_iterator() = default; explicit _Node_iterator(__node_type* __p) noexcept : __base_type(__p) { } reference operator*() const noexcept { return this->_M_cur->_M_v(); } pointer operator->() const noexcept { return this->_M_cur->_M_valptr(); } _Node_iterator& operator++() noexcept { this->_M_incr(); return *this; } _Node_iterator operator++(int) noexcept { _Node_iterator __tmp(*this); this->_M_incr(); return __tmp; } friend bool operator==(const _Node_iterator& __x, const _Node_iterator& __y) noexcept { const __base_type& __bx = __x; const __base_type& __by = __y; return __bx == __by; } friend bool operator!=(const _Node_iterator& __x, const _Node_iterator& __y) noexcept { return !(__x == __y); } }; template struct _Node_const_iterator : public _Node_iterator_base<_Value, __cache> { private: using __base_type = _Node_iterator_base<_Value, __cache>; using __node_type = typename __base_type::__node_type; using __iterator = _Node_iterator<_Value, __constant_iterators, __cache>; public: using value_type = _Value; using difference_type = ptrdiff_t; using iterator_category = forward_iterator_tag; using pointer = const value_type*; using reference = const value_type&; _Node_const_iterator() = default; explicit _Node_const_iterator(__node_type* __p) noexcept : __base_type(__p) { } _Node_const_iterator(const __iterator& __x) noexcept : __base_type(__x._M_cur) { } reference operator*() const noexcept { return this->_M_cur->_M_v(); } pointer operator->() const noexcept { return this->_M_cur->_M_valptr(); } _Node_const_iterator& operator++() noexcept { this->_M_incr(); return *this; } _Node_const_iterator operator++(int) noexcept { _Node_const_iterator __tmp(*this); this->_M_incr(); return __tmp; } # 531 "/usr/include/c++/15/bits/hashtable_policy.h" 3 friend bool operator==(const _Node_const_iterator& __x, const _Node_const_iterator& __y) noexcept { const __base_type& __bx = __x; const __base_type& __by = __y; return __bx == __by; } friend bool operator!=(const _Node_const_iterator& __x, const _Node_const_iterator& __y) noexcept { return !(__x == __y); } friend bool operator==(const _Node_const_iterator& __x, const __iterator& __y) noexcept { const __base_type& __bx = __x; const __base_type& __by = __y; return __bx == __by; } friend bool operator!=(const _Node_const_iterator& __x, const __iterator& __y) noexcept { return !(__x == __y); } friend bool operator==(const __iterator& __x, const _Node_const_iterator& __y) noexcept { const __base_type& __bx = __x; const __base_type& __by = __y; return __bx == __by; } friend bool operator!=(const __iterator& __x, const _Node_const_iterator& __y) noexcept { return !(__x == __y); } }; struct _Mod_range_hashing { size_t operator()(size_t __num, size_t __den) const noexcept { return __num % __den; } }; struct _Default_ranged_hash { }; struct _Prime_rehash_policy { using __has_load_factor = true_type; _Prime_rehash_policy(float __z = 1.0) noexcept : _M_max_load_factor(__z), _M_next_resize(0) { } float max_load_factor() const noexcept { return _M_max_load_factor; } size_t _M_next_bkt(size_t __n) const; size_t _M_bkt_for_elements(size_t __n) const { return __builtin_ceil(__n / (double)_M_max_load_factor); } std::pair _M_need_rehash(size_t __n_bkt, size_t __n_elt, size_t __n_ins) const; using _State = size_t; _State _M_state() const { return _M_next_resize; } void _M_reset() noexcept { _M_next_resize = 0; } void _M_reset(_State __state) { _M_next_resize = __state; } static const size_t _S_growth_factor = 2; float _M_max_load_factor; mutable size_t _M_next_resize; }; struct _Mask_range_hashing { size_t operator()(size_t __num, size_t __den) const noexcept { return __num & (__den - 1); } }; inline size_t __clp2(size_t __n) noexcept { using __gnu_cxx::__int_traits; if (__n < 2) return __n; const unsigned __lz = sizeof(size_t) > sizeof(long) ? __builtin_clzll(__n - 1ull) : __builtin_clzl(__n - 1ul); return (size_t(1) << (__int_traits::__digits - __lz - 1)) << 1; } struct _Power2_rehash_policy { using __has_load_factor = true_type; _Power2_rehash_policy(float __z = 1.0) noexcept : _M_max_load_factor(__z), _M_next_resize(0) { } float max_load_factor() const noexcept { return _M_max_load_factor; } size_t _M_next_bkt(size_t __n) noexcept { if (__n == 0) return 1; const auto __max_width = std::min(sizeof(size_t), 8); const auto __max_bkt = size_t(1) << (__max_width * 8 - 1); size_t __res = __clp2(__n); if (__res == 0) __res = __max_bkt; else if (__res == 1) __res = 2; if (__res == __max_bkt) _M_next_resize = size_t(-1); else _M_next_resize = __builtin_floor(__res * (double)_M_max_load_factor); return __res; } size_t _M_bkt_for_elements(size_t __n) const noexcept { return __builtin_ceil(__n / (double)_M_max_load_factor); } std::pair _M_need_rehash(size_t __n_bkt, size_t __n_elt, size_t __n_ins) noexcept { if (__n_elt + __n_ins > _M_next_resize) { double __min_bkts = std::max(__n_elt + __n_ins, _M_next_resize ? 0 : 11) / (double)_M_max_load_factor; if (__min_bkts >= __n_bkt) return { true, _M_next_bkt(std::max(__builtin_floor(__min_bkts) + 1, __n_bkt * _S_growth_factor)) }; _M_next_resize = __builtin_floor(__n_bkt * (double)_M_max_load_factor); return { false, 0 }; } else return { false, 0 }; } using _State = size_t; _State _M_state() const noexcept { return _M_next_resize; } void _M_reset() noexcept { _M_next_resize = 0; } void _M_reset(_State __state) noexcept { _M_next_resize = __state; } static const size_t _S_growth_factor = 2; float _M_max_load_factor; size_t _M_next_resize; }; template struct _RehashStateGuard { _RehashPolicy* _M_guarded_obj; typename _RehashPolicy::_State _M_prev_state; _RehashStateGuard(_RehashPolicy& __policy) : _M_guarded_obj(std::__addressof(__policy)) , _M_prev_state(__policy._M_state()) { } _RehashStateGuard(const _RehashStateGuard&) = delete; ~_RehashStateGuard() { if (_M_guarded_obj) _M_guarded_obj->_M_reset(_M_prev_state); } }; # 809 "/usr/include/c++/15/bits/hashtable_policy.h" 3 template struct _Map_base { }; template struct _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> { using mapped_type = _Val; }; template struct _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> { private: using __hashtable_base = _Hashtable_base<_Key, pair, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _Traits>; using __hashtable = _Hashtable<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>; using __hash_code = typename __hashtable_base::__hash_code; public: using key_type = typename __hashtable_base::key_type; using mapped_type = _Val; mapped_type& operator[](const key_type& __k); mapped_type& operator[](key_type&& __k); mapped_type& at(const key_type& __k) { auto __ite = static_cast<__hashtable*>(this)->find(__k); if (!__ite._M_cur) __throw_out_of_range(("unordered_map::at")); return __ite->second; } const mapped_type& at(const key_type& __k) const { auto __ite = static_cast(this)->find(__k); if (!__ite._M_cur) __throw_out_of_range(("unordered_map::at")); return __ite->second; } }; template auto _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: operator[](const key_type& __k) -> mapped_type& { __hashtable* __h = static_cast<__hashtable*>(this); __hash_code __code = __h->_M_hash_code(__k); size_t __bkt = __h->_M_bucket_index(__code); if (auto __node = __h->_M_find_node(__bkt, __k, __code)) return __node->_M_v().second; typename __hashtable::_Scoped_node __node { __h, std::piecewise_construct, std::tuple(__k), std::tuple<>() }; auto __pos = __h->_M_insert_unique_node(__bkt, __code, __node._M_node); __node._M_node = nullptr; return __pos->second; } template auto _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: operator[](key_type&& __k) -> mapped_type& { __hashtable* __h = static_cast<__hashtable*>(this); __hash_code __code = __h->_M_hash_code(__k); size_t __bkt = __h->_M_bucket_index(__code); if (auto __node = __h->_M_find_node(__bkt, __k, __code)) return __node->_M_v().second; typename __hashtable::_Scoped_node __node { __h, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::tuple<>() }; auto __pos = __h->_M_insert_unique_node(__bkt, __code, __node._M_node); __node._M_node = nullptr; return __pos->second; } template struct _Map_base, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq> : _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq> { }; template using __has_load_factor = typename _Policy::__has_load_factor; template> struct _Rehash_base; template struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false_type > { }; template struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true_type > { private: using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>; public: float max_load_factor() const noexcept { const __hashtable* __this = static_cast(this); return __this->__rehash_policy().max_load_factor(); } void max_load_factor(float __z) { __hashtable* __this = static_cast<__hashtable*>(this); __this->__rehash_policy(_RehashPolicy(__z)); } void reserve(size_t __n) { __hashtable* __this = static_cast<__hashtable*>(this); __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n)); } }; template struct _Hashtable_ebo_helper { [[__no_unique_address__]] _Tp _M_obj; }; template struct _Hashtable_ebo_helper<_Tp, false> { _Tp _M_obj; }; # 1034 "/usr/include/c++/15/bits/hashtable_policy.h" 3 template struct _Local_iterator_base; template struct _Hash_code_base { friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, false>; public: using hasher = _Hash; hasher hash_function() const { return _M_hash._M_obj; } protected: [[__no_unique_address__]] _Hashtable_ebo_helper<_Hash> _M_hash{}; using __hash_code = size_t; _Hash_code_base() = default; _Hash_code_base(const _Hash& __hash) : _M_hash{__hash} { } __hash_code _M_hash_code(const _Key& __k) const { static_assert(__is_invocable{}, "hash function must be invocable with an argument of key type"); return _M_hash._M_obj(__k); } template __hash_code _M_hash_code_tr(const _Kt& __k) const { static_assert(__is_invocable{}, "hash function must be invocable with an argument of key type"); return _M_hash._M_obj(__k); } __hash_code _M_hash_code(const _Hash_node_value<_Value, false>& __n) const { return _M_hash_code(_ExtractKey{}(__n._M_v())); } __hash_code _M_hash_code(const _Hash_node_value<_Value, true>& __n) const { return __n._M_hash_code; } size_t _M_bucket_index(__hash_code __c, size_t __bkt_count) const { return _RangeHash{}(__c, __bkt_count); } size_t _M_bucket_index(const _Hash_node_value<_Value, false>& __n, size_t __bkt_count) const noexcept( noexcept(declval()(declval())) ) { return _RangeHash{}(_M_hash_code(_ExtractKey{}(__n._M_v())), __bkt_count); } size_t _M_bucket_index(const _Hash_node_value<_Value, true>& __n, size_t __bkt_count) const noexcept { return _RangeHash{}(__n._M_hash_code, __bkt_count); } }; template struct _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, true> : public _Node_iterator_base<_Value, true> { protected: using __base_node_iter = _Node_iterator_base<_Value, true>; using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, true>; _Local_iterator_base() = default; _Local_iterator_base(const __hash_code_base&, _Hash_node<_Value, true>* __p, size_t __bkt, size_t __bkt_count) : __base_node_iter(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { } void _M_incr() { __base_node_iter::_M_incr(); if (this->_M_cur) { size_t __bkt = _RangeHash{}(this->_M_cur->_M_hash_code, _M_bucket_count); if (__bkt != _M_bucket) this->_M_cur = nullptr; } } size_t _M_bucket = 0; size_t _M_bucket_count = 0; public: size_t _M_get_bucket() const { return _M_bucket; } }; template struct _Hash_obj_storage { union _Uninit_storage { _Uninit_storage() noexcept { } ~_Uninit_storage() { } [[__no_unique_address__]] _Hash _M_h; }; [[__no_unique_address__]] _Uninit_storage _M_u; }; template struct _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, false> : _Hash_obj_storage<_Hash>, _Node_iterator_base<_Value, false> { protected: using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, false>; using __hash_obj_storage = _Hash_obj_storage<_Hash>; using __node_iter_base = _Node_iterator_base<_Value, false>; _Local_iterator_base() = default; _Local_iterator_base(const __hash_code_base& __base, _Hash_node<_Value, false>* __p, size_t __bkt, size_t __bkt_count) : __node_iter_base(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { _M_init(__base._M_hash._M_obj); } ~_Local_iterator_base() { if (_M_bucket_count != size_t(-1)) _M_destroy(); } _Local_iterator_base(const _Local_iterator_base& __iter) : __node_iter_base(__iter._M_cur), _M_bucket(__iter._M_bucket) , _M_bucket_count(__iter._M_bucket_count) { if (_M_bucket_count != size_t(-1)) _M_init(__iter._M_h()); } _Local_iterator_base& operator=(const _Local_iterator_base& __iter) { if (_M_bucket_count != size_t(-1)) _M_destroy(); this->_M_cur = __iter._M_cur; _M_bucket = __iter._M_bucket; _M_bucket_count = __iter._M_bucket_count; if (_M_bucket_count != size_t(-1)) _M_init(__iter._M_h()); return *this; } void _M_incr() { __node_iter_base::_M_incr(); if (this->_M_cur) { const auto __code = _M_h()(_ExtractKey{}(this->_M_cur->_M_v())); size_t __bkt = _RangeHash{}(__code, _M_bucket_count); if (__bkt != _M_bucket) this->_M_cur = nullptr; } } size_t _M_bucket = 0; size_t _M_bucket_count = -1; void _M_init(const _Hash& __h) { std::_Construct(std::__addressof(__hash_obj_storage::_M_u._M_h), __h); } void _M_destroy() { __hash_obj_storage::_M_u._M_h.~_Hash(); } const _Hash& _M_h() const { return __hash_obj_storage::_M_u._M_h; } public: size_t _M_get_bucket() const { return _M_bucket; } }; template struct _Local_iterator : public _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache> { private: using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache>; using __hash_code_base = typename __base_type::__hash_code_base; public: using value_type = _Value; using pointer = __conditional_t<__constant_iterators, const value_type*, value_type*>; using reference = __conditional_t<__constant_iterators, const value_type&, value_type&>; using difference_type = ptrdiff_t; using iterator_category = forward_iterator_tag; _Local_iterator() = default; _Local_iterator(const __hash_code_base& __base, _Hash_node<_Value, __cache>* __n, size_t __bkt, size_t __bkt_count) : __base_type(__base, __n, __bkt, __bkt_count) { } reference operator*() const { return this->_M_cur->_M_v(); } pointer operator->() const { return this->_M_cur->_M_valptr(); } _Local_iterator& operator++() { this->_M_incr(); return *this; } _Local_iterator operator++(int) { _Local_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; template struct _Local_const_iterator : public _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache> { private: using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache>; using __hash_code_base = typename __base_type::__hash_code_base; public: using value_type = _Value; using pointer = const value_type*; using reference = const value_type&; using difference_type = ptrdiff_t; using iterator_category = forward_iterator_tag; _Local_const_iterator() = default; _Local_const_iterator(const __hash_code_base& __base, _Hash_node<_Value, __cache>* __n, size_t __bkt, size_t __bkt_count) : __base_type(__base, __n, __bkt, __bkt_count) { } _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __constant_iterators, __cache>& __x) : __base_type(__x) { } reference operator*() const { return this->_M_cur->_M_v(); } pointer operator->() const { return this->_M_cur->_M_valptr(); } _Local_const_iterator& operator++() { this->_M_incr(); return *this; } _Local_const_iterator operator++(int) { _Local_const_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; # 1369 "/usr/include/c++/15/bits/hashtable_policy.h" 3 template struct _Hashtable_base : public _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, _Traits::__hash_cached::value> { public: using key_type = _Key; using value_type = _Value; using key_equal = _Equal; using size_type = size_t; using difference_type = ptrdiff_t; using __traits_type = _Traits; using __hash_cached = typename __traits_type::__hash_cached; using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __hash_cached::value>; using __hash_code = typename __hash_code_base::__hash_code; protected: [[__no_unique_address__]] _Hashtable_ebo_helper<_Equal> _M_equal{}; _Hashtable_base() = default; _Hashtable_base(const _Hash& __hash, const _Equal& __eq) : __hash_code_base(__hash), _M_equal{__eq} { } bool _M_key_equals(const _Key& __k, const _Hash_node_value<_Value, __hash_cached::value>& __n) const { static_assert(__is_invocable{}, "key equality predicate must be invocable with two arguments of " "key type"); return _M_eq()(__k, _ExtractKey{}(__n._M_v())); } template bool _M_key_equals_tr(const _Kt& __k, const _Hash_node_value<_Value, __hash_cached::value>& __n) const { static_assert( __is_invocable{}, "key equality predicate must be invocable with the argument type " "and the key type"); return _M_eq()(__k, _ExtractKey{}(__n._M_v())); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" bool _M_equals(const _Key& __k, __hash_code __c, const _Hash_node_value<_Value, __hash_cached::value>& __n) const { if constexpr (__hash_cached::value) if (__c != __n._M_hash_code) return false; return _M_key_equals(__k, __n); } template bool _M_equals_tr(const _Kt& __k, __hash_code __c, const _Hash_node_value<_Value, __hash_cached::value>& __n) const { if constexpr (__hash_cached::value) if (__c != __n._M_hash_code) return false; return _M_key_equals_tr(__k, __n); } bool _M_node_equals( const _Hash_node_value<_Value, __hash_cached::value>& __lhn, const _Hash_node_value<_Value, __hash_cached::value>& __rhn) const { if constexpr (__hash_cached::value) if (__lhn._M_hash_code != __rhn._M_hash_code) return false; return _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn); } #pragma GCC diagnostic pop const _Equal& _M_eq() const noexcept { return _M_equal._M_obj; } }; template struct _Hashtable_alloc { private: [[__no_unique_address__]] _Hashtable_ebo_helper<_NodeAlloc> _M_alloc{}; template struct __get_value_type; template struct __get_value_type<_Hash_node<_Val, _Cache_hash_code>> { using type = _Val; }; public: using __node_type = typename _NodeAlloc::value_type; using __node_alloc_type = _NodeAlloc; using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>; using __value_alloc_traits = typename __node_alloc_traits::template rebind_traits::type>; using __node_ptr = __node_type*; using __node_base = _Hash_node_base; using __node_base_ptr = __node_base*; using __buckets_alloc_type = __alloc_rebind<__node_alloc_type, __node_base_ptr>; using __buckets_alloc_traits = std::allocator_traits<__buckets_alloc_type>; using __buckets_ptr = __node_base_ptr*; _Hashtable_alloc() = default; _Hashtable_alloc(const _Hashtable_alloc&) = default; _Hashtable_alloc(_Hashtable_alloc&&) = default; template _Hashtable_alloc(_Alloc&& __a) : _M_alloc{std::forward<_Alloc>(__a)} { } __node_alloc_type& _M_node_allocator() { return _M_alloc._M_obj; } const __node_alloc_type& _M_node_allocator() const { return _M_alloc._M_obj; } template __node_ptr _M_allocate_node(_Args&&... __args); void _M_deallocate_node(__node_ptr __n); void _M_deallocate_node_ptr(__node_ptr __n); void _M_deallocate_nodes(__node_ptr __n); __buckets_ptr _M_allocate_buckets(size_t __bkt_count); void _M_deallocate_buckets(__buckets_ptr, size_t __bkt_count); }; template template auto _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) -> __node_ptr { auto& __alloc = _M_node_allocator(); auto __nptr = __node_alloc_traits::allocate(__alloc, 1); __node_ptr __n = std::__to_address(__nptr); try { ::new ((void*)__n) __node_type; __node_alloc_traits::construct(__alloc, __n->_M_valptr(), std::forward<_Args>(__args)...); return __n; } catch(...) { __n->~__node_type(); __node_alloc_traits::deallocate(__alloc, __nptr, 1); throw; } } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_ptr __n) { __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr()); _M_deallocate_node_ptr(__n); } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_ptr __n) { using _Ptr = typename __node_alloc_traits::pointer; auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n); __n->~__node_type(); __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1); } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_ptr __n) { while (__n) { __node_ptr __tmp = __n; __n = __n->_M_next(); _M_deallocate_node(__tmp); } } template auto _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(size_t __bkt_count) -> __buckets_ptr { __buckets_alloc_type __alloc(_M_node_allocator()); auto __ptr = __buckets_alloc_traits::allocate(__alloc, __bkt_count); __buckets_ptr __p = std::__to_address(__ptr); __builtin_memset(__p, 0, __bkt_count * sizeof(__node_base_ptr)); return __p; } template void _Hashtable_alloc<_NodeAlloc>:: _M_deallocate_buckets(__buckets_ptr __bkts, size_t __bkt_count) { using _Ptr = typename __buckets_alloc_traits::pointer; auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts); __buckets_alloc_type __alloc(_M_node_allocator()); __buckets_alloc_traits::deallocate(__alloc, __ptr, __bkt_count); } } } # 38 "/usr/include/c++/15/bits/hashtable.h" 2 3 # 1 "/usr/include/c++/15/bits/enable_special_members.h" 1 3 # 39 "/usr/include/c++/15/bits/enable_special_members.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct _Enable_default_constructor_tag { explicit constexpr _Enable_default_constructor_tag() = default; }; template struct _Enable_default_constructor { constexpr _Enable_default_constructor() noexcept = default; constexpr _Enable_default_constructor(_Enable_default_constructor const&) noexcept = default; constexpr _Enable_default_constructor(_Enable_default_constructor&&) noexcept = default; _Enable_default_constructor& operator=(_Enable_default_constructor const&) noexcept = default; _Enable_default_constructor& operator=(_Enable_default_constructor&&) noexcept = default; constexpr explicit _Enable_default_constructor(_Enable_default_constructor_tag) { } }; template struct _Enable_destructor { }; template struct _Enable_copy_move { }; # 98 "/usr/include/c++/15/bits/enable_special_members.h" 3 template struct _Enable_special_members : private _Enable_default_constructor<_Default, _Tag>, private _Enable_destructor<_Destructor, _Tag>, private _Enable_copy_move<_Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag> { }; template struct _Enable_default_constructor { constexpr _Enable_default_constructor() noexcept = delete; constexpr _Enable_default_constructor(_Enable_default_constructor const&) noexcept = default; constexpr _Enable_default_constructor(_Enable_default_constructor&&) noexcept = default; _Enable_default_constructor& operator=(_Enable_default_constructor const&) noexcept = default; _Enable_default_constructor& operator=(_Enable_default_constructor&&) noexcept = default; constexpr explicit _Enable_default_constructor(_Enable_default_constructor_tag) { } }; template struct _Enable_destructor { ~_Enable_destructor() noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = default; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = default; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; template struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; } # 39 "/usr/include/c++/15/bits/hashtable.h" 2 3 # 1 "/usr/include/c++/15/bits/node_handle.h" 1 3 # 38 "/usr/include/c++/15/bits/node_handle.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 39 "/usr/include/c++/15/bits/node_handle.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 66 "/usr/include/c++/15/bits/node_handle.h" 3 template class _Node_handle_common { using _AllocTraits = allocator_traits<_NodeAlloc>; public: using allocator_type = __alloc_rebind<_NodeAlloc, _Val>; allocator_type get_allocator() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return allocator_type(_M_alloc._M_alloc); } explicit operator bool() const noexcept { return _M_ptr != nullptr; } [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; } protected: constexpr _Node_handle_common() noexcept : _M_ptr() { } ~_Node_handle_common() { if (!empty()) _M_reset(); } _Node_handle_common(_Node_handle_common&& __nh) noexcept : _M_ptr(__nh._M_ptr) { if (_M_ptr) _M_move(std::move(__nh)); } _Node_handle_common& operator=(_Node_handle_common&& __nh) noexcept { if (empty()) { if (!__nh.empty()) _M_move(std::move(__nh)); } else if (__nh.empty()) _M_reset(); else { _AllocTraits::destroy(*_M_alloc, _M_ptr->_M_valptr()); _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1); _M_alloc = __nh._M_alloc.release(); _M_ptr = __nh._M_ptr; __nh._M_ptr = nullptr; } return *this; } _Node_handle_common(typename _AllocTraits::pointer __ptr, const _NodeAlloc& __alloc) : _M_ptr(__ptr), _M_alloc(__alloc) { do { if (std::__is_constant_evaluated() && !bool(__ptr != nullptr)) std::__glibcxx_assert_fail(); } while (false); } void _M_swap(_Node_handle_common& __nh) noexcept { if (empty()) { if (!__nh.empty()) _M_move(std::move(__nh)); } else if (__nh.empty()) __nh._M_move(std::move(*this)); else { using std::swap; swap(_M_ptr, __nh._M_ptr); _M_alloc.swap(__nh._M_alloc); } } private: void _M_move(_Node_handle_common&& __nh) noexcept { ::new (std::__addressof(_M_alloc)) _NodeAlloc(__nh._M_alloc.release()); _M_ptr = __nh._M_ptr; __nh._M_ptr = nullptr; } void _M_reset() noexcept { _NodeAlloc __alloc = _M_alloc.release(); _AllocTraits::destroy(__alloc, _M_ptr->_M_valptr()); _AllocTraits::deallocate(__alloc, _M_ptr, 1); _M_ptr = nullptr; } void release() noexcept { _M_alloc.release(); _M_ptr = nullptr; } protected: typename _AllocTraits::pointer _M_ptr; private: union _Optional_alloc { _Optional_alloc() { } ~_Optional_alloc() { } _Optional_alloc(_Optional_alloc&&) = delete; _Optional_alloc& operator=(_Optional_alloc&&) = delete; _Optional_alloc(const _NodeAlloc& __alloc) noexcept : _M_alloc(__alloc) { } void operator=(_NodeAlloc&& __alloc) noexcept { using _ATr = _AllocTraits; if constexpr (_ATr::propagate_on_container_move_assignment::value) _M_alloc = std::move(__alloc); else if constexpr (!_AllocTraits::is_always_equal::value) do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __alloc)) std::__glibcxx_assert_fail(); } while (false); } void swap(_Optional_alloc& __other) noexcept { using std::swap; if constexpr (_AllocTraits::propagate_on_container_swap::value) swap(_M_alloc, __other._M_alloc); else if constexpr (!_AllocTraits::is_always_equal::value) do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __other._M_alloc)) std::__glibcxx_assert_fail(); } while (false); } _NodeAlloc& operator*() noexcept { return _M_alloc; } _NodeAlloc release() noexcept { _NodeAlloc __tmp = std::move(_M_alloc); _M_alloc.~_NodeAlloc(); return __tmp; } [[__no_unique_address__]] _NodeAlloc _M_alloc; }; [[__no_unique_address__]] _Optional_alloc _M_alloc; template friend class _Rb_tree; template friend class _Hashtable; }; template class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc> { public: constexpr _Node_handle() noexcept = default; ~_Node_handle() = default; _Node_handle(_Node_handle&&) noexcept = default; _Node_handle& operator=(_Node_handle&&) noexcept = default; using key_type = _Key; using mapped_type = typename _Value::second_type; key_type& key() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *_M_pkey; } mapped_type& mapped() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *_M_pmapped; } void swap(_Node_handle& __nh) noexcept { this->_M_swap(__nh); using std::swap; swap(_M_pkey, __nh._M_pkey); swap(_M_pmapped, __nh._M_pmapped); } friend void swap(_Node_handle& __x, _Node_handle& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } private: using _AllocTraits = allocator_traits<_NodeAlloc>; _Node_handle(typename _AllocTraits::pointer __ptr, const _NodeAlloc& __alloc) : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { if (__ptr) { auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first); _M_pkey = _S_pointer_to(__key); _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second); } else { _M_pkey = nullptr; _M_pmapped = nullptr; } } template using __pointer = __ptr_rebind>; __pointer<_Key> _M_pkey = nullptr; __pointer _M_pmapped = nullptr; template __pointer<_Tp> _S_pointer_to(_Tp& __obj) { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); } const key_type& _M_key() const noexcept { return key(); } template friend class _Rb_tree; template friend class _Hashtable; }; template class _Node_handle<_Value, _Value, _NodeAlloc> : public _Node_handle_common<_Value, _NodeAlloc> { public: constexpr _Node_handle() noexcept = default; ~_Node_handle() = default; _Node_handle(_Node_handle&&) noexcept = default; _Node_handle& operator=(_Node_handle&&) noexcept = default; using value_type = _Value; value_type& value() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *this->_M_ptr->_M_valptr(); } void swap(_Node_handle& __nh) noexcept { this->_M_swap(__nh); } friend void swap(_Node_handle& __x, _Node_handle& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } private: using _AllocTraits = allocator_traits<_NodeAlloc>; _Node_handle(typename _AllocTraits::pointer __ptr, const _NodeAlloc& __alloc) : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { } const value_type& _M_key() const noexcept { return value(); } template friend class _Rb_tree; template friend class _Hashtable; }; template struct _Node_insert_return { _Iterator position = _Iterator(); bool inserted = false; _NodeHandle node; }; } # 43 "/usr/include/c++/15/bits/hashtable.h" 2 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template using __cache_default = __not_<__and_< __is_fast_hash<_Hash>, __is_nothrow_invocable>>; template using _Hashtable_enable_default_ctor = _Enable_default_constructor<__and_, is_default_constructible<_Hash>, is_default_constructible<_Allocator>>{}, __detail::_Hash_node_base>; # 185 "/usr/include/c++/15/bits/hashtable.h" 3 template class _Hashtable : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _Traits>, public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>, public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>, private __detail::_Hashtable_alloc< __alloc_rebind<_Alloc, __detail::_Hash_node<_Value, _Traits::__hash_cached::value>>>, private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc> { static_assert(is_same::type, _Value>::value, "unordered container must have a non-const, non-volatile value_type"); static_assert(is_copy_constructible<_Hash>::value, "hash function must be copy constructible"); using __traits_type = _Traits; using __hash_cached = typename __traits_type::__hash_cached; using __constant_iterators = typename __traits_type::__constant_iterators; using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>; using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; using __node_value_type = __detail::_Hash_node_value<_Value, __hash_cached::value>; using __node_ptr = typename __hashtable_alloc::__node_ptr; using __value_alloc_traits = typename __hashtable_alloc::__value_alloc_traits; using __node_alloc_traits = typename __hashtable_alloc::__node_alloc_traits; using __node_base = typename __hashtable_alloc::__node_base; using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr; using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr; using __enable_default_ctor = _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>; using __rehash_guard_t = __detail::_RehashStateGuard<_RehashPolicy>; public: typedef _Key key_type; typedef _Value value_type; typedef _Alloc allocator_type; typedef _Equal key_equal; typedef typename __value_alloc_traits::pointer pointer; typedef typename __value_alloc_traits::const_pointer const_pointer; typedef value_type& reference; typedef const value_type& const_reference; using iterator = __detail::_Node_iterator<_Value, __constant_iterators::value, __hash_cached::value>; using const_iterator = __detail::_Node_const_iterator<_Value, __constant_iterators::value, __hash_cached::value>; using local_iterator = __detail::_Local_iterator; using const_local_iterator = __detail::_Local_const_iterator< key_type, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __constant_iterators::value, __hash_cached::value>; private: using __rehash_type = _RehashPolicy; using __unique_keys = typename __traits_type::__unique_keys; using __hashtable_base = __detail:: _Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _Traits>; using __hash_code_base = typename __hashtable_base::__hash_code_base; using __hash_code = typename __hashtable_base::__hash_code; using __ireturn_type = __conditional_t<__unique_keys::value, std::pair, iterator>; using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>; using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>; using __node_builder_t = __detail::_NodeBuilder<_ExtractKey>; struct _Scoped_node { _Scoped_node(__node_ptr __n, __hashtable_alloc* __h) : _M_h(__h), _M_node(__n) { } template _Scoped_node(__hashtable_alloc* __h, _Args&&... __args) : _M_h(__h), _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...)) { } ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); }; _Scoped_node(const _Scoped_node&) = delete; _Scoped_node& operator=(const _Scoped_node&) = delete; __hashtable_alloc* _M_h; __node_ptr _M_node; }; struct __hash_code_base_access : __hash_code_base { using __hash_code_base::_M_bucket_index; }; static_assert(is_nothrow_default_constructible<_RangeHash>::value, "Functor used to map hash code to bucket index" " must be nothrow default constructible"); static_assert(noexcept( std::declval()((std::size_t)0, (std::size_t)0)), "Functor used to map hash code to bucket index must be" " noexcept"); static_assert(is_nothrow_default_constructible<_ExtractKey>::value, "_ExtractKey must be nothrow default constructible"); static_assert(noexcept( std::declval()(std::declval<_Value>())), "_ExtractKey functor must be noexcept invocable"); template friend struct __detail::_Map_base; public: using size_type = typename __hashtable_base::size_type; using difference_type = typename __hashtable_base::difference_type; using node_type = _Node_handle<_Key, _Value, __node_alloc_type>; using insert_return_type = _Node_insert_return; private: __buckets_ptr _M_buckets = &_M_single_bucket; size_type _M_bucket_count = 1; __node_base _M_before_begin; size_type _M_element_count = 0; _RehashPolicy _M_rehash_policy; __node_base_ptr _M_single_bucket = nullptr; void _M_update_bbegin() { if (auto __begin = _M_begin()) _M_buckets[_M_bucket_index(*__begin)] = &_M_before_begin; } void _M_update_bbegin(__node_ptr __n) { _M_before_begin._M_nxt = __n; _M_update_bbegin(); } bool _M_uses_single_bucket(__buckets_ptr __bkts) const { return __builtin_expect(__bkts == &_M_single_bucket, false); } bool _M_uses_single_bucket() const { return _M_uses_single_bucket(_M_buckets); } static constexpr size_t __small_size_threshold() noexcept { return __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold(); } __hashtable_alloc& _M_base_alloc() { return *this; } __buckets_ptr _M_allocate_buckets(size_type __bkt_count) { if (__builtin_expect(__bkt_count == 1, false)) { _M_single_bucket = nullptr; return &_M_single_bucket; } return __hashtable_alloc::_M_allocate_buckets(__bkt_count); } void _M_deallocate_buckets(__buckets_ptr __bkts, size_type __bkt_count) { if (_M_uses_single_bucket(__bkts)) return; __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count); } void _M_deallocate_buckets() { _M_deallocate_buckets(_M_buckets, _M_bucket_count); } __node_ptr _M_bucket_begin(size_type __bkt) const { __node_base_ptr __n = _M_buckets[__bkt]; return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr; } __node_ptr _M_begin() const { return static_cast<__node_ptr>(_M_before_begin._M_nxt); } template void _M_assign_elements(_Ht&&); template void _M_assign(_Ht&& __ht) { __detail::_AllocNode<__node_alloc_type> __alloc_node_gen(*this); _M_assign(std::forward<_Ht>(__ht), __alloc_node_gen); } template void _M_assign(_Ht&&, _NodeGenerator&); void _M_move_assign(_Hashtable&&, true_type); void _M_move_assign(_Hashtable&&, false_type); void _M_reset() noexcept; _Hashtable(const _Hash& __h, const _Equal& __eq, const allocator_type& __a) : __hashtable_base(__h, __eq), __hashtable_alloc(__node_alloc_type(__a)), __enable_default_ctor(_Enable_default_constructor_tag{}) { } template static constexpr bool _S_nothrow_move() { if constexpr (_No_realloc) if constexpr (is_nothrow_copy_constructible<_Hash>()) return is_nothrow_copy_constructible<_Equal>(); return false; } _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, true_type ) noexcept(_S_nothrow_move()); _Hashtable(_Hashtable&&, __node_alloc_type&&, false_type ); template _Hashtable(_InputIterator __first, _InputIterator __last, size_type __bkt_count_hint, const _Hash&, const _Equal&, const allocator_type&, true_type __uks); template _Hashtable(_InputIterator __first, _InputIterator __last, size_type __bkt_count_hint, const _Hash&, const _Equal&, const allocator_type&, false_type __uks); public: _Hashtable() = default; _Hashtable(const _Hashtable&); _Hashtable(const _Hashtable&, const allocator_type&); explicit _Hashtable(size_type __bkt_count_hint, const _Hash& __hf = _Hash(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()); _Hashtable(_Hashtable&& __ht) noexcept(_S_nothrow_move()) : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()), true_type{}) { } _Hashtable(_Hashtable&& __ht, const allocator_type& __a) noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>()) : _Hashtable(std::move(__ht), __node_alloc_type(__a), typename __node_alloc_traits::is_always_equal{}) { } explicit _Hashtable(const allocator_type& __a) : __hashtable_alloc(__node_alloc_type(__a)), __enable_default_ctor(_Enable_default_constructor_tag{}) { } template _Hashtable(_InputIterator __f, _InputIterator __l, size_type __bkt_count_hint = 0, const _Hash& __hf = _Hash(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a, __unique_keys{}) { } _Hashtable(initializer_list __l, size_type __bkt_count_hint = 0, const _Hash& __hf = _Hash(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint, __hf, __eql, __a, __unique_keys{}) { } _Hashtable& operator=(const _Hashtable& __ht); _Hashtable& operator=(_Hashtable&& __ht) noexcept(__node_alloc_traits::_S_nothrow_move() && is_nothrow_move_assignable<_Hash>::value && is_nothrow_move_assignable<_Equal>::value) { constexpr bool __move_storage = __node_alloc_traits::_S_propagate_on_move_assign() || __node_alloc_traits::_S_always_equal(); _M_move_assign(std::move(__ht), __bool_constant<__move_storage>()); return *this; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" _Hashtable& operator=(initializer_list __l) { using __reuse_or_alloc_node_gen_t = __detail::_ReuseOrAllocNode<__node_alloc_type>; __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); _M_before_begin._M_nxt = nullptr; clear(); auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size()); if (_M_bucket_count < __l_bkt_count) rehash(__l_bkt_count); __hash_code __code; size_type __bkt; for (auto& __e : __l) { const key_type& __k = _ExtractKey{}(__e); if constexpr (__unique_keys::value) { if (auto __loc = _M_locate(__k)) continue; else { __code = __loc._M_hash_code; __bkt = __loc._M_bucket_index; } } else { __code = this->_M_hash_code(__k); __bkt = _M_bucket_index(__code); } _M_insert_unique_node(__bkt, __code, __roan(__e)); } return *this; } #pragma GCC diagnostic pop ~_Hashtable() noexcept; void swap(_Hashtable&) noexcept(__and_<__is_nothrow_swappable<_Hash>, __is_nothrow_swappable<_Equal>>::value); iterator begin() noexcept { return iterator(_M_begin()); } const_iterator begin() const noexcept { return const_iterator(_M_begin()); } iterator end() noexcept { return iterator(nullptr); } const_iterator end() const noexcept { return const_iterator(nullptr); } const_iterator cbegin() const noexcept { return const_iterator(_M_begin()); } const_iterator cend() const noexcept { return const_iterator(nullptr); } size_type size() const noexcept { return _M_element_count; } [[__nodiscard__]] bool empty() const noexcept { return size() == 0; } allocator_type get_allocator() const noexcept { return allocator_type(this->_M_node_allocator()); } size_type max_size() const noexcept { return __node_alloc_traits::max_size(this->_M_node_allocator()); } key_equal key_eq() const { return this->_M_eq(); } size_type bucket_count() const noexcept { return _M_bucket_count; } size_type max_bucket_count() const noexcept { return max_size(); } size_type bucket_size(size_type __bkt) const { return std::distance(begin(__bkt), end(__bkt)); } size_type bucket(const key_type& __k) const { return _M_bucket_index(this->_M_hash_code(__k)); } local_iterator begin(size_type __bkt) { return local_iterator(*this, _M_bucket_begin(__bkt), __bkt, _M_bucket_count); } local_iterator end(size_type __bkt) { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); } const_local_iterator begin(size_type __bkt) const { return const_local_iterator(*this, _M_bucket_begin(__bkt), __bkt, _M_bucket_count); } const_local_iterator end(size_type __bkt) const { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } const_local_iterator cbegin(size_type __bkt) const { return const_local_iterator(*this, _M_bucket_begin(__bkt), __bkt, _M_bucket_count); } const_local_iterator cend(size_type __bkt) const { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } float load_factor() const noexcept { return static_cast(size()) / static_cast(bucket_count()); } const _RehashPolicy& __rehash_policy() const { return _M_rehash_policy; } void __rehash_policy(const _RehashPolicy& __pol) { _M_rehash_policy = __pol; } iterator find(const key_type& __k); const_iterator find(const key_type& __k) const; size_type count(const key_type& __k) const; std::pair equal_range(const key_type& __k); std::pair equal_range(const key_type& __k) const; # 801 "/usr/include/c++/15/bits/hashtable.h" 3 void _M_rehash_insert(size_type __n); private: size_type _M_bucket_index(const __node_value_type& __n) const noexcept { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } size_type _M_bucket_index(__hash_code __c) const { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" __hash_code _M_hash_code_ext(const __node_value_type& __from) const { if constexpr (__and_<__hash_cached, is_empty<_Hash>>::value) return __from._M_hash_code; else return this->_M_hash_code(_ExtractKey{}(__from._M_v())); } size_type _M_bucket_index_ext(const __node_value_type& __from) const { return _RangeHash{}(_M_hash_code_ext(__from), _M_bucket_count); } void _M_copy_code(__node_value_type& __to, const __node_value_type& __from) const { if constexpr (__hash_cached::value) __to._M_hash_code = _M_hash_code_ext(__from); } void _M_store_code(__node_value_type& __to, __hash_code __code) const { if constexpr (__hash_cached::value) __to._M_hash_code = __code; } #pragma GCC diagnostic pop __node_base_ptr _M_find_before_node(size_type, const key_type&, __hash_code) const; template __node_base_ptr _M_find_before_node_tr(size_type, const _Kt&, __hash_code) const; struct __location_type { explicit operator bool() const noexcept { return static_cast(_M_before); } explicit operator iterator() const noexcept { return iterator(_M_node()); } explicit operator const_iterator() const noexcept { return const_iterator(_M_node()); } __node_ptr _M_node() const { if (_M_before) return static_cast<__node_ptr>(_M_before->_M_nxt); return __node_ptr(); } __node_base_ptr _M_before{}; __hash_code _M_hash_code{}; size_type _M_bucket_index = size_type(-1); }; # 902 "/usr/include/c++/15/bits/hashtable.h" 3 __location_type _M_locate(const key_type& __k) const; __node_ptr _M_find_node(size_type __bkt, const key_type& __key, __hash_code __c) const { if (__node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c)) return static_cast<__node_ptr>(__before_n->_M_nxt); return nullptr; } template __node_ptr _M_find_node_tr(size_type __bkt, const _Kt& __key, __hash_code __c) const { if (auto __before_n = _M_find_before_node_tr(__bkt, __key, __c)) return static_cast<__node_ptr>(__before_n->_M_nxt); return nullptr; } void _M_insert_bucket_begin(size_type __bkt, __node_ptr __node) { if (_M_buckets[__bkt]) { __node->_M_nxt = _M_buckets[__bkt]->_M_nxt; _M_buckets[__bkt]->_M_nxt = __node; } else { __node->_M_nxt = _M_before_begin._M_nxt; _M_before_begin._M_nxt = __node; if (__node->_M_nxt) _M_buckets[_M_bucket_index(*__node->_M_next())] = __node; _M_buckets[__bkt] = &_M_before_begin; } } void _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n, size_type __next_bkt) { if (!__next_n) _M_buckets[__bkt] = nullptr; else if (__next_bkt != __bkt) { _M_buckets[__next_bkt] = _M_buckets[__bkt]; _M_buckets[__bkt] = nullptr; } } __node_base_ptr _M_get_previous_node(size_type __bkt, __node_ptr __n); pair<__node_ptr, __hash_code> _M_compute_hash_code(__node_ptr __hint, const key_type& __k) const; iterator _M_insert_unique_node(size_type __bkt, __hash_code, __node_ptr __n, size_type __n_elt = 1); iterator _M_insert_multi_node(__node_ptr __hint, __hash_code __code, __node_ptr __n); template std::pair _M_emplace_uniq(_Args&&... __args); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++14-extensions" template, typename = _ExtractKey> static constexpr bool __is_key_type = false; template static constexpr bool __is_key_type<_Arg, key_type, __detail::_Identity> = true; template static constexpr bool __is_key_type<_Arg, pair<_Arg1, _Arg2>, __detail::_Select1st> = is_same<__remove_cvref_t<_Arg1>, key_type>::value; #pragma GCC diagnostic pop template iterator _M_emplace_multi(const_iterator, _Args&&... __args); iterator _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n); template void _M_insert_range_multi(_InputIterator __first, _InputIterator __last); public: #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template __ireturn_type emplace(_Args&&... __args) { if constexpr (__unique_keys::value) return _M_emplace_uniq(std::forward<_Args>(__args)...); else return _M_emplace_multi(cend(), std::forward<_Args>(__args)...); } template iterator emplace_hint(const_iterator __hint, _Args&&... __args) { if constexpr (__unique_keys::value) return _M_emplace_uniq(std::forward<_Args>(__args)...).first; else return _M_emplace_multi(__hint, std::forward<_Args>(__args)...); } __ireturn_type insert(const value_type& __v) { if constexpr (__unique_keys::value) return _M_emplace_uniq(__v); else return _M_emplace_multi(cend(), __v); } iterator insert(const_iterator __hint, const value_type& __v) { if constexpr (__unique_keys::value) return _M_emplace_uniq(__v).first; else return _M_emplace_multi(__hint, __v); } __ireturn_type insert(value_type&& __v) { if constexpr (__unique_keys::value) return _M_emplace_uniq(std::move(__v)); else return _M_emplace_multi(cend(), std::move(__v)); } iterator insert(const_iterator __hint, value_type&& __v) { if constexpr (__unique_keys::value) return _M_emplace_uniq(std::move(__v)).first; else return _M_emplace_multi(__hint, std::move(__v)); } template std::pair try_emplace(const_iterator, _KType&& __k, _Args&&... __args) { __hash_code __code; size_type __bkt; if (auto __loc = _M_locate(__k)) return { iterator(__loc), false }; else { __code = __loc._M_hash_code; __bkt = __loc._M_bucket_index; } _Scoped_node __node { this, std::piecewise_construct, std::forward_as_tuple(std::forward<_KType>(__k)), std::forward_as_tuple(std::forward<_Args>(__args)...) }; auto __it = _M_insert_unique_node(__bkt, __code, __node._M_node); __node._M_node = nullptr; return { __it, true }; } void insert(initializer_list __l) { this->insert(__l.begin(), __l.end()); } template void insert(_InputIterator __first, _InputIterator __last) { if constexpr (__unique_keys::value) for (; __first != __last; ++__first) _M_emplace_uniq(*__first); else return _M_insert_range_multi(__first, __last); } template>, is_constructible>> __ireturn_type insert(_Pair&& __v) { if constexpr (__unique_keys::value) return _M_emplace_uniq(std::forward<_Pair>(__v)); else return _M_emplace_multi(cend(), std::forward<_Pair>(__v)); } template>, is_constructible>> iterator insert(const_iterator __hint, _Pair&& __v) { if constexpr (__unique_keys::value) return _M_emplace_uniq(std::forward<_Pair>(__v)); else return _M_emplace_multi(__hint, std::forward<_Pair>(__v)); } #pragma GCC diagnostic pop iterator erase(const_iterator); iterator erase(iterator __it) { return erase(const_iterator(__it)); } size_type erase(const key_type& __k); iterator erase(const_iterator, const_iterator); void clear() noexcept; void rehash(size_type __bkt_count); insert_return_type _M_reinsert_node(node_type&& __nh) { insert_return_type __ret; if (__nh.empty()) __ret.position = end(); else { do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) std::__glibcxx_assert_fail(); } while (false); if (auto __loc = _M_locate(__nh._M_key())) { __ret.node = std::move(__nh); __ret.position = iterator(__loc); __ret.inserted = false; } else { auto __code = __loc._M_hash_code; auto __bkt = __loc._M_bucket_index; __ret.position = _M_insert_unique_node(__bkt, __code, __nh._M_ptr); __ret.inserted = true; __nh.release(); } } return __ret; } iterator _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh) { if (__nh.empty()) return end(); do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) std::__glibcxx_assert_fail(); } while (false); const key_type& __k = __nh._M_key(); auto __code = this->_M_hash_code(__k); auto __ret = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr); __nh.release(); return __ret; } private: node_type _M_extract_node(size_t __bkt, __node_base_ptr __prev_n) { __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt); if (__prev_n == _M_buckets[__bkt]) _M_remove_bucket_begin(__bkt, __n->_M_next(), __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); else if (__n->_M_nxt) { size_type __next_bkt = _M_bucket_index(*__n->_M_next()); if (__next_bkt != __bkt) _M_buckets[__next_bkt] = __prev_n; } __prev_n->_M_nxt = __n->_M_nxt; __n->_M_nxt = nullptr; --_M_element_count; return { __n, this->_M_node_allocator() }; } template __hash_code _M_src_hash_code(const _H2&, const __node_value_type& __src_n) const { if constexpr (__and_<__hash_cached, is_same<_H2, _Hash>, is_empty<_Hash>>::value) return __src_n._M_hash_code; else return this->_M_hash_code(_ExtractKey{}(__src_n._M_v())); } public: node_type extract(const_iterator __pos) { size_t __bkt = _M_bucket_index(*__pos._M_cur); return _M_extract_node(__bkt, _M_get_previous_node(__bkt, __pos._M_cur)); } node_type extract(const _Key& __k) { node_type __nh; __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__code); if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code)) __nh = _M_extract_node(__bkt, __prev_node); return __nh; } void _M_merge_unique(_Hashtable& __src) { do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false); using _PTr = pointer_traits<__node_base_ptr>; auto __n_elt = __src.size(); size_type __first = 1; auto __prev = _PTr::pointer_to(__src._M_before_begin); while (__n_elt--) { const auto __next = __prev->_M_nxt; const auto& __node = static_cast<__node_type&>(*__next); const key_type& __k = _ExtractKey{}(__node._M_v()); const auto __loc = _M_locate(__k); if (__loc) { __prev = __next; continue; } auto __src_bkt = __src._M_bucket_index(__node); auto __nh = __src._M_extract_node(__src_bkt, __prev); _M_insert_unique_node(__loc._M_bucket_index, __loc._M_hash_code, __nh._M_ptr, __first * __n_elt + 1); __nh.release(); __first = 0; } } template void _M_merge_unique(_Compatible_Hashtable& __src) { static_assert(is_same_v, "Node types are compatible"); do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false); auto __n_elt = __src.size(); size_type __first = 1; for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) { --__n_elt; auto __pos = __i++; const key_type& __k = _ExtractKey{}(*__pos); const auto __loc = _M_locate(__k); if (__loc) continue; auto __nh = __src.extract(__pos); _M_insert_unique_node(__loc._M_bucket_index, __loc._M_hash_code, __nh._M_ptr, __first * __n_elt + 1); __nh.release(); __first = 0; } } void _M_merge_multi(_Hashtable& __src) { do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false); if (__src.size() == 0) [[__unlikely__]] return; using _PTr = pointer_traits<__node_base_ptr>; __node_ptr __hint = nullptr; this->reserve(size() + __src.size()); auto __prev = _PTr::pointer_to(__src._M_before_begin); do { const auto& __node = static_cast<__node_type&>(*__prev->_M_nxt); auto __code = _M_hash_code_ext(__node); size_type __src_bkt = __src._M_bucket_index(__node); auto __nh = __src._M_extract_node(__src_bkt, __prev); __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur; __nh.release(); } while (__prev->_M_nxt != nullptr); } template void _M_merge_multi(_Compatible_Hashtable& __src) { static_assert(is_same_v, "Node types are compatible"); do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false); __node_ptr __hint = nullptr; this->reserve(size() + __src.size()); for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) { auto __pos = __i++; __hash_code __code = _M_src_hash_code(__src.hash_function(), *__pos._M_cur); auto __nh = __src.extract(__pos); __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur; __nh.release(); } } bool _M_equal(const _Hashtable& __other) const; private: void _M_rehash(size_type __bkt_count, true_type __uks); void _M_rehash(size_type __bkt_count, false_type __uks); }; template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(size_type __bkt_count_hint, const _Hash& __h, const _Equal& __eq, const allocator_type& __a) : _Hashtable(__h, __eq, __a) { auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint); if (__bkt_count > _M_bucket_count) { _M_buckets = _M_allocate_buckets(__bkt_count); _M_bucket_count = __bkt_count; } } template template inline _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(_InputIterator __f, _InputIterator __l, size_type __bkt_count_hint, const _Hash& __h, const _Equal& __eq, const allocator_type& __a, true_type ) : _Hashtable(__bkt_count_hint, __h, __eq, __a) { this->insert(__f, __l); } template template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(_InputIterator __f, _InputIterator __l, size_type __bkt_count_hint, const _Hash& __h, const _Equal& __eq, const allocator_type& __a, false_type __uks) : _Hashtable(__h, __eq, __a) { auto __nb_elems = __detail::__distance_fw(__f, __l); auto __bkt_count = _M_rehash_policy._M_next_bkt( std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), __bkt_count_hint)); if (__bkt_count > _M_bucket_count) { _M_buckets = _M_allocate_buckets(__bkt_count); _M_bucket_count = __bkt_count; } for (; __f != __l; ++__f) _M_emplace_multi(cend(), *__f); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: operator=(const _Hashtable& __ht) -> _Hashtable& { if (&__ht == this) return *this; if (__node_alloc_traits::_S_propagate_on_copy_assign()) { auto& __this_alloc = this->_M_node_allocator(); auto& __that_alloc = __ht._M_node_allocator(); if (!__node_alloc_traits::_S_always_equal() && __this_alloc != __that_alloc) { this->_M_deallocate_nodes(_M_begin()); _M_before_begin._M_nxt = nullptr; _M_deallocate_buckets(); _M_buckets = nullptr; std::__alloc_on_copy(__this_alloc, __that_alloc); __hashtable_base::operator=(__ht); _M_bucket_count = __ht._M_bucket_count; _M_element_count = __ht._M_element_count; _M_rehash_policy = __ht._M_rehash_policy; struct _Guard { ~_Guard() { if (_M_ht) _M_ht->_M_reset(); } _Hashtable* _M_ht; }; _Guard __guard{this}; _M_assign(__ht); __guard._M_ht = nullptr; return *this; } std::__alloc_on_copy(__this_alloc, __that_alloc); } _M_assign_elements(__ht); return *this; } template template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_assign_elements(_Ht&& __ht) { using __reuse_or_alloc_node_gen_t = __detail::_ReuseOrAllocNode<__node_alloc_type>; __buckets_ptr __former_buckets = nullptr; std::size_t __former_bucket_count = _M_bucket_count; __rehash_guard_t __rehash_guard(_M_rehash_policy); if (_M_bucket_count != __ht._M_bucket_count) { __former_buckets = _M_buckets; _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); _M_bucket_count = __ht._M_bucket_count; } else std::fill_n(_M_buckets, _M_bucket_count, nullptr); try { __hashtable_base::operator=(std::forward<_Ht>(__ht)); _M_element_count = __ht._M_element_count; _M_rehash_policy = __ht._M_rehash_policy; __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); _M_before_begin._M_nxt = nullptr; _M_assign(std::forward<_Ht>(__ht), __roan); if (__former_buckets) _M_deallocate_buckets(__former_buckets, __former_bucket_count); __rehash_guard._M_guarded_obj = nullptr; } catch(...) { if (__former_buckets) { _M_deallocate_buckets(); _M_buckets = __former_buckets; _M_bucket_count = __former_bucket_count; } std::fill_n(_M_buckets, _M_bucket_count, nullptr); throw; } } template template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_assign(_Ht&& __ht, _NodeGenerator& __node_gen) { struct _Guard { ~_Guard() { if (_M_ht) { _M_ht->clear(); if (_M_dealloc_buckets) _M_ht->_M_deallocate_buckets(); } } _Hashtable* _M_ht = nullptr; bool _M_dealloc_buckets = false; }; _Guard __guard; if (!_M_buckets) { _M_buckets = _M_allocate_buckets(_M_bucket_count); __guard._M_dealloc_buckets = true; } if (!__ht._M_before_begin._M_nxt) return; __guard._M_ht = this; using _FromVal = __conditional_t::value, const value_type&, value_type&&>; __node_ptr __ht_n = __ht._M_begin(); __node_ptr __this_n = __node_gen(static_cast<_FromVal>(__ht_n->_M_v())); _M_copy_code(*__this_n, *__ht_n); _M_update_bbegin(__this_n); __node_ptr __prev_n = __this_n; for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) { __this_n = __node_gen(static_cast<_FromVal>(__ht_n->_M_v())); __prev_n->_M_nxt = __this_n; _M_copy_code(*__this_n, *__ht_n); size_type __bkt = _M_bucket_index(*__this_n); if (!_M_buckets[__bkt]) _M_buckets[__bkt] = __prev_n; __prev_n = __this_n; } __guard._M_ht = nullptr; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_reset() noexcept { _M_rehash_policy._M_reset(); _M_bucket_count = 1; _M_single_bucket = nullptr; _M_buckets = &_M_single_bucket; _M_before_begin._M_nxt = nullptr; _M_element_count = 0; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_move_assign(_Hashtable&& __ht, true_type) { if (__builtin_expect(std::__addressof(__ht) == this, false)) return; this->_M_deallocate_nodes(_M_begin()); _M_deallocate_buckets(); __hashtable_base::operator=(std::move(__ht)); _M_rehash_policy = __ht._M_rehash_policy; if (!__ht._M_uses_single_bucket()) _M_buckets = __ht._M_buckets; else { _M_buckets = &_M_single_bucket; _M_single_bucket = __ht._M_single_bucket; } _M_bucket_count = __ht._M_bucket_count; _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; _M_element_count = __ht._M_element_count; std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); _M_update_bbegin(); __ht._M_reset(); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_move_assign(_Hashtable&& __ht, false_type) { if (__ht._M_node_allocator() == this->_M_node_allocator()) _M_move_assign(std::move(__ht), true_type{}); else { _M_assign_elements(std::move(__ht)); __ht.clear(); } } template inline _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(const _Hashtable& __ht) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc( __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), __enable_default_ctor(__ht), _M_buckets(nullptr), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { _M_assign(__ht); } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, true_type ) noexcept(_S_nothrow_move()) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc(std::move(__a)), __enable_default_ctor(__ht), _M_buckets(__ht._M_buckets), _M_bucket_count(__ht._M_bucket_count), _M_before_begin(__ht._M_before_begin._M_nxt), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { if (__ht._M_uses_single_bucket()) { _M_buckets = &_M_single_bucket; _M_single_bucket = __ht._M_single_bucket; } _M_update_bbegin(); __ht._M_reset(); } template inline _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(const _Hashtable& __ht, const allocator_type& __a) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc(__node_alloc_type(__a)), __enable_default_ctor(__ht), _M_buckets(), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { _M_assign(__ht); } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, false_type ) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc(std::move(__a)), __enable_default_ctor(__ht), _M_buckets(nullptr), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { if (__ht._M_node_allocator() == this->_M_node_allocator()) { if (__ht._M_uses_single_bucket()) { _M_buckets = &_M_single_bucket; _M_single_bucket = __ht._M_single_bucket; } else _M_buckets = __ht._M_buckets; _M_update_bbegin(__ht._M_begin()); __ht._M_reset(); } else { using _Fwd_Ht = __conditional_t< __move_if_noexcept_cond::value, const _Hashtable&, _Hashtable&&>; _M_assign(std::forward<_Fwd_Ht>(__ht)); __ht.clear(); } } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: ~_Hashtable() noexcept { static_assert(noexcept(declval() ._M_bucket_index(declval(), (std::size_t)0)), "Cache the hash code or qualify your functors involved" " in hash code and bucket index computation with noexcept"); this->_M_deallocate_nodes(_M_begin()); _M_deallocate_buckets(); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: swap(_Hashtable& __x) noexcept(__and_<__is_nothrow_swappable<_Hash>, __is_nothrow_swappable<_Equal>>::value) { using std::swap; swap(__hash_code_base::_M_hash._M_obj, __x.__hash_code_base::_M_hash._M_obj); swap(__hashtable_base::_M_equal._M_obj, __x.__hashtable_base::_M_equal._M_obj); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" if constexpr (__node_alloc_traits::propagate_on_container_swap::value) swap(this->_M_node_allocator(), __x._M_node_allocator()); #pragma GCC diagnostic pop std::swap(_M_rehash_policy, __x._M_rehash_policy); if (this->_M_uses_single_bucket()) { if (!__x._M_uses_single_bucket()) { _M_buckets = __x._M_buckets; __x._M_buckets = &__x._M_single_bucket; } } else if (__x._M_uses_single_bucket()) { __x._M_buckets = _M_buckets; _M_buckets = &_M_single_bucket; } else std::swap(_M_buckets, __x._M_buckets); std::swap(_M_bucket_count, __x._M_bucket_count); std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); std::swap(_M_element_count, __x._M_element_count); std::swap(_M_single_bucket, __x._M_single_bucket); _M_update_bbegin(); __x._M_update_bbegin(); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: find(const key_type& __k) -> iterator { return iterator(_M_locate(__k)); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: find(const key_type& __k) const -> const_iterator { return const_iterator(_M_locate(__k)); } # 1981 "/usr/include/c++/15/bits/hashtable.h" 3 template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: count(const key_type& __k) const -> size_type { auto __it = find(__k); if (!__it._M_cur) return 0; if (__unique_keys::value) return 1; size_type __result = 1; for (auto __ref = __it++; __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur); ++__it) ++__result; return __result; } # 2054 "/usr/include/c++/15/bits/hashtable.h" 3 template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: equal_range(const key_type& __k) -> pair { auto __ite = find(__k); if (!__ite._M_cur) return { __ite, __ite }; auto __beg = __ite++; if (__unique_keys::value) return { __beg, __ite }; while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) ++__ite; return { __beg, __ite }; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: equal_range(const key_type& __k) const -> pair { auto __ite = find(__k); if (!__ite._M_cur) return { __ite, __ite }; auto __beg = __ite++; if (__unique_keys::value) return { __beg, __ite }; while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) ++__ite; return { __beg, __ite }; } # 2194 "/usr/include/c++/15/bits/hashtable.h" 3 template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_find_before_node(size_type __bkt, const key_type& __k, __hash_code __code) const -> __node_base_ptr { __node_base_ptr __prev_p = _M_buckets[__bkt]; if (!__prev_p) return nullptr; for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; __p = __p->_M_next()) { if (this->_M_equals(__k, __code, *__p)) return __prev_p; if (__builtin_expect (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt, 0)) break; __prev_p = __p; } return nullptr; } template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_find_before_node_tr(size_type __bkt, const _Kt& __k, __hash_code __code) const -> __node_base_ptr { __node_base_ptr __prev_p = _M_buckets[__bkt]; if (!__prev_p) return nullptr; for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; __p = __p->_M_next()) { if (this->_M_equals_tr(__k, __code, *__p)) return __prev_p; if (__builtin_expect (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt, 0)) break; __prev_p = __p; } return nullptr; } template inline auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_locate(const key_type& __k) const -> __location_type { __location_type __loc; const auto __size = size(); if (__size <= __small_size_threshold()) { __loc._M_before = pointer_traits<__node_base_ptr>:: pointer_to(const_cast<__node_base&>(_M_before_begin)); while (__loc._M_before->_M_nxt) { if (this->_M_key_equals(__k, *__loc._M_node())) return __loc; __loc._M_before = __loc._M_before->_M_nxt; } __loc._M_before = nullptr; } __loc._M_hash_code = this->_M_hash_code(__k); __loc._M_bucket_index = _M_bucket_index(__loc._M_hash_code); if (__size > __small_size_threshold()) __loc._M_before = _M_find_before_node(__loc._M_bucket_index, __k, __loc._M_hash_code); return __loc; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_get_previous_node(size_type __bkt, __node_ptr __n) -> __node_base_ptr { __node_base_ptr __prev_n = _M_buckets[__bkt]; while (__prev_n->_M_nxt != __n) __prev_n = __prev_n->_M_nxt; return __prev_n; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_emplace_uniq(_Args&&... __args) -> pair { const key_type* __kp = nullptr; if constexpr (sizeof...(_Args) == 1) { if constexpr (__is_key_type<_Args...>) { const auto& __key = _ExtractKey{}(__args...); __kp = std::__addressof(__key); } } else if constexpr (sizeof...(_Args) == 2) { if constexpr (__is_key_type>) { pair __refs(__args...); const auto& __key = _ExtractKey{}(__refs); __kp = std::__addressof(__key); } } _Scoped_node __node { __node_ptr(), this }; __hash_code __code = 0; size_type __bkt = 0; if (__kp == nullptr) { __node._M_node = this->_M_allocate_node(std::forward<_Args>(__args)...); const key_type& __key = _ExtractKey{}(__node._M_node->_M_v()); __kp = std::__addressof(__key); } if (auto __loc = _M_locate(*__kp)) return { iterator(__loc), false }; else { __code = __loc._M_hash_code; __bkt = __loc._M_bucket_index; } if (!__node._M_node) __node._M_node = this->_M_allocate_node(std::forward<_Args>(__args)...); auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node); __node._M_node = nullptr; return { __pos, true }; } #pragma GCC diagnostic pop template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_emplace_multi(const_iterator __hint, _Args&&... __args) -> iterator { _Scoped_node __node { this, std::forward<_Args>(__args)... }; const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); auto __res = this->_M_compute_hash_code(__hint._M_cur, __k); auto __pos = _M_insert_multi_node(__res.first, __res.second, __node._M_node); __node._M_node = nullptr; return __pos; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_rehash_insert(size_type __n) { using __pair_type = std::pair; if (__n == 0) return; __rehash_guard_t __rehash_guard(_M_rehash_policy); __pair_type __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, __n); if (__do_rehash.first) _M_rehash(__do_rehash.second, false_type{}); __rehash_guard._M_guarded_obj = nullptr; } template template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_insert_range_multi(_InputIterator __first, _InputIterator __last) { _M_rehash_insert(__detail::__distance_fw(__first, __last)); for (; __first != __last; ++__first) _M_emplace_multi(cend(), *__first); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_compute_hash_code(__node_ptr __hint, const key_type& __k) const -> pair<__node_ptr, __hash_code> { if (size() <= __small_size_threshold()) { if (__hint) { for (auto __it = __hint; __it; __it = __it->_M_next()) if (this->_M_key_equals(__k, *__it)) return { __it, this->_M_hash_code(*__it) }; } for (auto __it = _M_begin(); __it != __hint; __it = __it->_M_next()) if (this->_M_key_equals(__k, *__it)) return { __it, this->_M_hash_code(*__it) }; __hint = nullptr; } return { __hint, this->_M_hash_code(__k) }; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_insert_unique_node(size_type __bkt, __hash_code __code, __node_ptr __node, size_type __n_elt) -> iterator { __rehash_guard_t __rehash_guard(_M_rehash_policy); std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, __n_elt); if (__do_rehash.first) { _M_rehash(__do_rehash.second, true_type{}); __bkt = _M_bucket_index(__code); } __rehash_guard._M_guarded_obj = nullptr; _M_store_code(*__node, __code); _M_insert_bucket_begin(__bkt, __node); ++_M_element_count; return iterator(__node); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_insert_multi_node(__node_ptr __hint, __hash_code __code, __node_ptr __node) -> iterator { __rehash_guard_t __rehash_guard(_M_rehash_policy); std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); if (__do_rehash.first) _M_rehash(__do_rehash.second, false_type{}); __rehash_guard._M_guarded_obj = nullptr; _M_store_code(*__node, __code); const key_type& __k = _ExtractKey{}(__node->_M_v()); size_type __bkt = _M_bucket_index(__code); __node_base_ptr __prev = __builtin_expect(__hint != nullptr, false) && this->_M_equals(__k, __code, *__hint) ? __hint : _M_find_before_node(__bkt, __k, __code); if (__prev) { __node->_M_nxt = __prev->_M_nxt; __prev->_M_nxt = __node; if (__builtin_expect(__prev == __hint, false)) if (__node->_M_nxt && !this->_M_equals(__k, __code, *__node->_M_next())) { size_type __next_bkt = _M_bucket_index(*__node->_M_next()); if (__next_bkt != __bkt) _M_buckets[__next_bkt] = __node; } } else _M_insert_bucket_begin(__bkt, __node); ++_M_element_count; return iterator(__node); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: erase(const_iterator __it) -> iterator { __node_ptr __n = __it._M_cur; std::size_t __bkt = _M_bucket_index(*__n); __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); return _M_erase(__bkt, __prev_n, __n); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n) -> iterator { if (__prev_n == _M_buckets[__bkt]) _M_remove_bucket_begin(__bkt, __n->_M_next(), __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); else if (__n->_M_nxt) { size_type __next_bkt = _M_bucket_index(*__n->_M_next()); if (__next_bkt != __bkt) _M_buckets[__next_bkt] = __prev_n; } __prev_n->_M_nxt = __n->_M_nxt; iterator __result(__n->_M_next()); this->_M_deallocate_node(__n); --_M_element_count; return __result; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: erase(const key_type& __k) -> size_type { auto __loc = _M_locate(__k); if (!__loc) return 0; __node_base_ptr __prev_n = __loc._M_before; __node_ptr __n = __loc._M_node(); auto __bkt = __loc._M_bucket_index; if (__bkt == size_type(-1)) __bkt = _M_bucket_index(*__n); if constexpr (__unique_keys::value) { _M_erase(__bkt, __prev_n, __n); return 1; } else { __node_ptr __n_last = __n->_M_next(); while (__n_last && this->_M_node_equals(*__n, *__n_last)) __n_last = __n_last->_M_next(); std::size_t __n_last_bkt = __n_last ? _M_bucket_index(*__n_last) : __bkt; size_type __result = 0; do { __node_ptr __p = __n->_M_next(); this->_M_deallocate_node(__n); __n = __p; ++__result; } while (__n != __n_last); _M_element_count -= __result; if (__prev_n == _M_buckets[__bkt]) _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); else if (__n_last_bkt != __bkt) _M_buckets[__n_last_bkt] = __prev_n; __prev_n->_M_nxt = __n_last; return __result; } } #pragma GCC diagnostic pop template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: erase(const_iterator __first, const_iterator __last) -> iterator { __node_ptr __n = __first._M_cur; __node_ptr __last_n = __last._M_cur; if (__n == __last_n) return iterator(__n); std::size_t __bkt = _M_bucket_index(*__n); __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); std::size_t __n_bkt = __bkt; for (;;) { do { __node_ptr __tmp = __n; __n = __n->_M_next(); this->_M_deallocate_node(__tmp); --_M_element_count; if (!__n) break; __n_bkt = _M_bucket_index(*__n); } while (__n != __last_n && __n_bkt == __bkt); if (__is_bucket_begin) _M_remove_bucket_begin(__bkt, __n, __n_bkt); if (__n == __last_n) break; __is_bucket_begin = true; __bkt = __n_bkt; } if (__n && (__n_bkt != __bkt || __is_bucket_begin)) _M_buckets[__n_bkt] = __prev_n; __prev_n->_M_nxt = __n; return iterator(__n); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: clear() noexcept { this->_M_deallocate_nodes(_M_begin()); std::fill_n(_M_buckets, _M_bucket_count, nullptr); _M_element_count = 0; _M_before_begin._M_nxt = nullptr; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: rehash(size_type __bkt_count) { __rehash_guard_t __rehash_guard(_M_rehash_policy); __bkt_count = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), __bkt_count); __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count); if (__bkt_count != _M_bucket_count) { _M_rehash(__bkt_count, __unique_keys{}); __rehash_guard._M_guarded_obj = nullptr; } } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_rehash(size_type __bkt_count, true_type ) { __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); __node_ptr __p = _M_begin(); _M_before_begin._M_nxt = nullptr; std::size_t __bbegin_bkt = 0; while (__p) { __node_ptr __next = __p->_M_next(); std::size_t __bkt = __hash_code_base::_M_bucket_index(*__p, __bkt_count); if (!__new_buckets[__bkt]) { __p->_M_nxt = _M_before_begin._M_nxt; _M_before_begin._M_nxt = __p; __new_buckets[__bkt] = &_M_before_begin; if (__p->_M_nxt) __new_buckets[__bbegin_bkt] = __p; __bbegin_bkt = __bkt; } else { __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; __new_buckets[__bkt]->_M_nxt = __p; } __p = __next; } _M_deallocate_buckets(); _M_bucket_count = __bkt_count; _M_buckets = __new_buckets; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_rehash(size_type __bkt_count, false_type ) { __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); __node_ptr __p = _M_begin(); _M_before_begin._M_nxt = nullptr; std::size_t __bbegin_bkt = 0; std::size_t __prev_bkt = 0; __node_ptr __prev_p = nullptr; bool __check_bucket = false; while (__p) { __node_ptr __next = __p->_M_next(); std::size_t __bkt = __hash_code_base::_M_bucket_index(*__p, __bkt_count); if (__prev_p && __prev_bkt == __bkt) { __p->_M_nxt = __prev_p->_M_nxt; __prev_p->_M_nxt = __p; __check_bucket = true; } else { if (__check_bucket) { if (__prev_p->_M_nxt) { std::size_t __next_bkt = __hash_code_base::_M_bucket_index( *__prev_p->_M_next(), __bkt_count); if (__next_bkt != __prev_bkt) __new_buckets[__next_bkt] = __prev_p; } __check_bucket = false; } if (!__new_buckets[__bkt]) { __p->_M_nxt = _M_before_begin._M_nxt; _M_before_begin._M_nxt = __p; __new_buckets[__bkt] = &_M_before_begin; if (__p->_M_nxt) __new_buckets[__bbegin_bkt] = __p; __bbegin_bkt = __bkt; } else { __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; __new_buckets[__bkt]->_M_nxt = __p; } } __prev_p = __p; __prev_bkt = __bkt; __p = __next; } if (__check_bucket && __prev_p->_M_nxt) { std::size_t __next_bkt = __hash_code_base::_M_bucket_index(*__prev_p->_M_next(), __bkt_count); if (__next_bkt != __prev_bkt) __new_buckets[__next_bkt] = __prev_p; } _M_deallocate_buckets(); _M_bucket_count = __bkt_count; _M_buckets = __new_buckets; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template bool _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: _M_equal(const _Hashtable& __other) const { if (size() != __other.size()) return false; if constexpr (__unique_keys::value) for (auto __x_n = _M_begin(); __x_n; __x_n = __x_n->_M_next()) { std::size_t __ybkt = __other._M_bucket_index_ext(*__x_n); auto __prev_n = __other._M_buckets[__ybkt]; if (!__prev_n) return false; for (__node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt);; __n = __n->_M_next()) { if (__n->_M_v() == __x_n->_M_v()) break; if (!__n->_M_nxt || __other._M_bucket_index(*__n->_M_next()) != __ybkt) return false; } } else for (auto __x_n = _M_begin(); __x_n;) { std::size_t __x_count = 1; auto __x_n_end = __x_n->_M_next(); for (; __x_n_end && key_eq()(_ExtractKey{}(__x_n->_M_v()), _ExtractKey{}(__x_n_end->_M_v())); __x_n_end = __x_n_end->_M_next()) ++__x_count; std::size_t __ybkt = __other._M_bucket_index_ext(*__x_n); auto __y_prev_n = __other._M_buckets[__ybkt]; if (!__y_prev_n) return false; __node_ptr __y_n = static_cast<__node_ptr>(__y_prev_n->_M_nxt); for (;;) { if (key_eq()(_ExtractKey{}(__y_n->_M_v()), _ExtractKey{}(__x_n->_M_v()))) break; auto __y_ref_n = __y_n; for (__y_n = __y_n->_M_next(); __y_n; __y_n = __y_n->_M_next()) if (!__other._M_node_equals(*__y_ref_n, *__y_n)) break; if (!__y_n || __other._M_bucket_index(*__y_n) != __ybkt) return false; } auto __y_n_end = __y_n; for (; __y_n_end; __y_n_end = __y_n_end->_M_next()) if (--__x_count == 0) break; if (__x_count != 0) return false; const_iterator __itx(__x_n), __itx_end(__x_n_end); const_iterator __ity(__y_n); if (!std::is_permutation(__itx, __itx_end, __ity)) return false; __x_n = __x_n_end; } return true; } #pragma GCC diagnostic pop template class _Hash_merge_helper { }; template using _RequireNotAllocatorOrIntegral = __enable_if_t, __is_allocator<_Hash>>::value>; } #pragma GCC diagnostic pop # 34 "/usr/include/c++/15/bits/unordered_map.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>; template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator >, typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>> using __umap_hashtable = _Hashtable<_Key, std::pair, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>; template using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>; template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator >, typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>> using __ummap_hashtable = _Hashtable<_Key, std::pair, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>; template class unordered_multimap; # 108 "/usr/include/c++/15/bits/unordered_map.h" 3 template, typename _Pred = equal_to<_Key>, typename _Alloc = allocator>> class unordered_map { typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; _Hashtable _M_h; public: typedef typename _Hashtable::key_type key_type; typedef typename _Hashtable::value_type value_type; typedef typename _Hashtable::mapped_type mapped_type; typedef typename _Hashtable::hasher hasher; typedef typename _Hashtable::key_equal key_equal; typedef typename _Hashtable::allocator_type allocator_type; typedef typename _Hashtable::pointer pointer; typedef typename _Hashtable::const_pointer const_pointer; typedef typename _Hashtable::reference reference; typedef typename _Hashtable::const_reference const_reference; typedef typename _Hashtable::iterator iterator; typedef typename _Hashtable::const_iterator const_iterator; typedef typename _Hashtable::local_iterator local_iterator; typedef typename _Hashtable::const_local_iterator const_local_iterator; typedef typename _Hashtable::size_type size_type; typedef typename _Hashtable::difference_type difference_type; using node_type = typename _Hashtable::node_type; using insert_return_type = typename _Hashtable::insert_return_type; unordered_map() = default; # 160 "/usr/include/c++/15/bits/unordered_map.h" 3 explicit unordered_map(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__n, __hf, __eql, __a) { } # 181 "/usr/include/c++/15/bits/unordered_map.h" 3 template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__first, __last, __n, __hf, __eql, __a) { } unordered_map(const unordered_map&) = default; unordered_map(unordered_map&&) = default; explicit unordered_map(const allocator_type& __a) : _M_h(__a) { } unordered_map(const unordered_map& __umap, const allocator_type& __a) : _M_h(__umap._M_h, __a) { } unordered_map(unordered_map&& __umap, const allocator_type& __a) noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) ) : _M_h(std::move(__umap._M_h), __a) { } # 237 "/usr/include/c++/15/bits/unordered_map.h" 3 unordered_map(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__l, __n, __hf, __eql, __a) { } unordered_map(size_type __n, const allocator_type& __a) : unordered_map(__n, hasher(), key_equal(), __a) { } unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__n, __hf, key_equal(), __a) { } template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__first, __last, __n, __hf, key_equal(), __a) { } unordered_map(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_map(__l, __n, hasher(), key_equal(), __a) { } unordered_map(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__l, __n, __hf, key_equal(), __a) { } # 324 "/usr/include/c++/15/bits/unordered_map.h" 3 unordered_map& operator=(const unordered_map&) = default; unordered_map& operator=(unordered_map&&) = default; # 342 "/usr/include/c++/15/bits/unordered_map.h" 3 unordered_map& operator=(initializer_list __l) { _M_h = __l; return *this; } allocator_type get_allocator() const noexcept { return _M_h.get_allocator(); } [[__nodiscard__]] bool empty() const noexcept { return _M_h.empty(); } size_type size() const noexcept { return _M_h.size(); } size_type max_size() const noexcept { return _M_h.max_size(); } iterator begin() noexcept { return _M_h.begin(); } const_iterator begin() const noexcept { return _M_h.begin(); } const_iterator cbegin() const noexcept { return _M_h.begin(); } iterator end() noexcept { return _M_h.end(); } const_iterator end() const noexcept { return _M_h.end(); } const_iterator cend() const noexcept { return _M_h.end(); } # 439 "/usr/include/c++/15/bits/unordered_map.h" 3 template std::pair emplace(_Args&&... __args) { return _M_h.emplace(std::forward<_Args>(__args)...); } # 470 "/usr/include/c++/15/bits/unordered_map.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } node_type extract(const_iterator __pos) { do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false); return _M_h.extract(__pos); } node_type extract(const key_type& __key) { return _M_h.extract(__key); } insert_return_type insert(node_type&& __nh) { return _M_h._M_reinsert_node(std::move(__nh)); } iterator insert(const_iterator, node_type&& __nh) { return _M_h._M_reinsert_node(std::move(__nh)).position; } # 523 "/usr/include/c++/15/bits/unordered_map.h" 3 template pair try_emplace(const key_type& __k, _Args&&... __args) { return _M_h.try_emplace(cend(), __k, std::forward<_Args>(__args)...); } template pair try_emplace(key_type&& __k, _Args&&... __args) { return _M_h.try_emplace(cend(), std::move(__k), std::forward<_Args>(__args)...); } # 567 "/usr/include/c++/15/bits/unordered_map.h" 3 template iterator try_emplace(const_iterator __hint, const key_type& __k, _Args&&... __args) { return _M_h.try_emplace(__hint, __k, std::forward<_Args>(__args)...).first; } template iterator try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args) { return _M_h.try_emplace(__hint, std::move(__k), std::forward<_Args>(__args)...).first; } # 604 "/usr/include/c++/15/bits/unordered_map.h" 3 std::pair insert(const value_type& __x) { return _M_h.insert(__x); } std::pair insert(value_type&& __x) { return _M_h.insert(std::move(__x)); } template __enable_if_t::value, pair> insert(_Pair&& __x) { return _M_h.emplace(std::forward<_Pair>(__x)); } # 643 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator insert(const_iterator __hint, const value_type& __x) { return _M_h.insert(__hint, __x); } iterator insert(const_iterator __hint, value_type&& __x) { return _M_h.insert(__hint, std::move(__x)); } template __enable_if_t::value, iterator> insert(const_iterator __hint, _Pair&& __x) { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } # 668 "/usr/include/c++/15/bits/unordered_map.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_h.insert(__first, __last); } # 680 "/usr/include/c++/15/bits/unordered_map.h" 3 void insert(initializer_list __l) { _M_h.insert(__l); } # 723 "/usr/include/c++/15/bits/unordered_map.h" 3 template pair insert_or_assign(const key_type& __k, _Obj&& __obj) { auto __ret = _M_h.try_emplace(cend(), __k, std::forward<_Obj>(__obj)); if (!__ret.second) __ret.first->second = std::forward<_Obj>(__obj); return __ret; } template pair insert_or_assign(key_type&& __k, _Obj&& __obj) { auto __ret = _M_h.try_emplace(cend(), std::move(__k), std::forward<_Obj>(__obj)); if (!__ret.second) __ret.first->second = std::forward<_Obj>(__obj); return __ret; } # 772 "/usr/include/c++/15/bits/unordered_map.h" 3 template iterator insert_or_assign(const_iterator __hint, const key_type& __k, _Obj&& __obj) { auto __ret = _M_h.try_emplace(__hint, __k, std::forward<_Obj>(__obj)); if (!__ret.second) __ret.first->second = std::forward<_Obj>(__obj); return __ret.first; } template iterator insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) { auto __ret = _M_h.try_emplace(__hint, std::move(__k), std::forward<_Obj>(__obj)); if (!__ret.second) __ret.first->second = std::forward<_Obj>(__obj); return __ret.first; } # 810 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator erase(const_iterator __position) { return _M_h.erase(__position); } iterator erase(iterator __position) { return _M_h.erase(__position); } # 832 "/usr/include/c++/15/bits/unordered_map.h" 3 size_type erase(const key_type& __x) { return _M_h.erase(__x); } # 850 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_h.erase(__first, __last); } void clear() noexcept { _M_h.clear(); } # 874 "/usr/include/c++/15/bits/unordered_map.h" 3 void swap(unordered_map& __x) noexcept( noexcept(_M_h.swap(__x._M_h)) ) { _M_h.swap(__x._M_h); } template friend class std::_Hash_merge_helper; template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) { if constexpr (is_same_v<_H2, _Hash> && is_same_v<_P2, _Pred>) if (std::__addressof(__source) == this) [[__unlikely__]] return; using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { merge(__source); } hasher hash_function() const { return _M_h.hash_function(); } key_equal key_eq() const { return _M_h.key_eq(); } # 945 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator find(const key_type& __x) { return _M_h.find(__x); } # 956 "/usr/include/c++/15/bits/unordered_map.h" 3 const_iterator find(const key_type& __x) const { return _M_h.find(__x); } # 978 "/usr/include/c++/15/bits/unordered_map.h" 3 size_type count(const key_type& __x) const { return _M_h.count(__x); } # 1018 "/usr/include/c++/15/bits/unordered_map.h" 3 std::pair equal_range(const key_type& __x) { return _M_h.equal_range(__x); } # 1030 "/usr/include/c++/15/bits/unordered_map.h" 3 std::pair equal_range(const key_type& __x) const { return _M_h.equal_range(__x); } # 1056 "/usr/include/c++/15/bits/unordered_map.h" 3 mapped_type& operator[](const key_type& __k) { return _M_h[__k]; } mapped_type& operator[](key_type&& __k) { return _M_h[std::move(__k)]; } # 1073 "/usr/include/c++/15/bits/unordered_map.h" 3 mapped_type& at(const key_type& __k) { return _M_h.at(__k); } const mapped_type& at(const key_type& __k) const { return _M_h.at(__k); } size_type bucket_count() const noexcept { return _M_h.bucket_count(); } size_type max_bucket_count() const noexcept { return _M_h.max_bucket_count(); } size_type bucket_size(size_type __n) const { return _M_h.bucket_size(__n); } size_type bucket(const key_type& __key) const { return _M_h.bucket(__key); } local_iterator begin(size_type __n) { return _M_h.begin(__n); } # 1129 "/usr/include/c++/15/bits/unordered_map.h" 3 const_local_iterator begin(size_type __n) const { return _M_h.begin(__n); } const_local_iterator cbegin(size_type __n) const { return _M_h.cbegin(__n); } # 1144 "/usr/include/c++/15/bits/unordered_map.h" 3 local_iterator end(size_type __n) { return _M_h.end(__n); } # 1155 "/usr/include/c++/15/bits/unordered_map.h" 3 const_local_iterator end(size_type __n) const { return _M_h.end(__n); } const_local_iterator cend(size_type __n) const { return _M_h.cend(__n); } float load_factor() const noexcept { return _M_h.load_factor(); } float max_load_factor() const noexcept { return _M_h.max_load_factor(); } void max_load_factor(float __z) { _M_h.max_load_factor(__z); } # 1192 "/usr/include/c++/15/bits/unordered_map.h" 3 void rehash(size_type __n) { _M_h.rehash(__n); } # 1203 "/usr/include/c++/15/bits/unordered_map.h" 3 void reserve(size_type __n) { _M_h.reserve(__n); } template friend bool operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); }; template>, typename _Pred = equal_to<__iter_key_t<_InputIterator>>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, typename unordered_map::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, _Pred, _Allocator>; template, typename _Pred = equal_to<_Key>, typename _Allocator = allocator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_map(initializer_list>, typename unordered_map::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, typename unordered_map::size_type, _Allocator) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, _Allocator) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, typename unordered_map::size_type, _Hash, _Allocator) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template> unordered_map(initializer_list>, typename unordered_map::size_type, _Allocator) -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template> unordered_map(initializer_list>, _Allocator) -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_map(initializer_list>, typename unordered_map::size_type, _Hash, _Allocator) -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; # 1362 "/usr/include/c++/15/bits/unordered_map.h" 3 template, typename _Pred = equal_to<_Key>, typename _Alloc = allocator>> class unordered_multimap { typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; _Hashtable _M_h; public: typedef typename _Hashtable::key_type key_type; typedef typename _Hashtable::value_type value_type; typedef typename _Hashtable::mapped_type mapped_type; typedef typename _Hashtable::hasher hasher; typedef typename _Hashtable::key_equal key_equal; typedef typename _Hashtable::allocator_type allocator_type; typedef typename _Hashtable::pointer pointer; typedef typename _Hashtable::const_pointer const_pointer; typedef typename _Hashtable::reference reference; typedef typename _Hashtable::const_reference const_reference; typedef typename _Hashtable::iterator iterator; typedef typename _Hashtable::const_iterator const_iterator; typedef typename _Hashtable::local_iterator local_iterator; typedef typename _Hashtable::const_local_iterator const_local_iterator; typedef typename _Hashtable::size_type size_type; typedef typename _Hashtable::difference_type difference_type; using node_type = typename _Hashtable::node_type; unordered_multimap() = default; # 1413 "/usr/include/c++/15/bits/unordered_map.h" 3 explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__n, __hf, __eql, __a) { } # 1434 "/usr/include/c++/15/bits/unordered_map.h" 3 template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__first, __last, __n, __hf, __eql, __a) { } unordered_multimap(const unordered_multimap&) = default; unordered_multimap(unordered_multimap&&) = default; explicit unordered_multimap(const allocator_type& __a) : _M_h(__a) { } unordered_multimap(const unordered_multimap& __ummap, const allocator_type& __a) : _M_h(__ummap._M_h, __a) { } unordered_multimap(unordered_multimap&& __ummap, const allocator_type& __a) noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) ) : _M_h(std::move(__ummap._M_h), __a) { } # 1490 "/usr/include/c++/15/bits/unordered_map.h" 3 unordered_multimap(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__l, __n, __hf, __eql, __a) { } unordered_multimap(size_type __n, const allocator_type& __a) : unordered_multimap(__n, hasher(), key_equal(), __a) { } unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__n, __hf, key_equal(), __a) { } template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) { } unordered_multimap(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_multimap(__l, __n, hasher(), key_equal(), __a) { } unordered_multimap(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__l, __n, __hf, key_equal(), __a) { } # 1577 "/usr/include/c++/15/bits/unordered_map.h" 3 unordered_multimap& operator=(const unordered_multimap&) = default; unordered_multimap& operator=(unordered_multimap&&) = default; # 1595 "/usr/include/c++/15/bits/unordered_map.h" 3 unordered_multimap& operator=(initializer_list __l) { _M_h = __l; return *this; } allocator_type get_allocator() const noexcept { return _M_h.get_allocator(); } [[__nodiscard__]] bool empty() const noexcept { return _M_h.empty(); } size_type size() const noexcept { return _M_h.size(); } size_type max_size() const noexcept { return _M_h.max_size(); } iterator begin() noexcept { return _M_h.begin(); } const_iterator begin() const noexcept { return _M_h.begin(); } const_iterator cbegin() const noexcept { return _M_h.begin(); } iterator end() noexcept { return _M_h.end(); } const_iterator end() const noexcept { return _M_h.end(); } const_iterator cend() const noexcept { return _M_h.end(); } # 1687 "/usr/include/c++/15/bits/unordered_map.h" 3 template iterator emplace(_Args&&... __args) { return _M_h.emplace(std::forward<_Args>(__args)...); } # 1714 "/usr/include/c++/15/bits/unordered_map.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } # 1729 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator insert(const value_type& __x) { return _M_h.insert(__x); } iterator insert(value_type&& __x) { return _M_h.insert(std::move(__x)); } template __enable_if_t::value, iterator> insert(_Pair&& __x) { return _M_h.emplace(std::forward<_Pair>(__x)); } # 1763 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator insert(const_iterator __hint, const value_type& __x) { return _M_h.insert(__hint, __x); } iterator insert(const_iterator __hint, value_type&& __x) { return _M_h.insert(__hint, std::move(__x)); } template __enable_if_t::value, iterator> insert(const_iterator __hint, _Pair&& __x) { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } # 1788 "/usr/include/c++/15/bits/unordered_map.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_h.insert(__first, __last); } # 1801 "/usr/include/c++/15/bits/unordered_map.h" 3 void insert(initializer_list __l) { _M_h.insert(__l); } # 1833 "/usr/include/c++/15/bits/unordered_map.h" 3 node_type extract(const_iterator __pos) { do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false); return _M_h.extract(__pos); } node_type extract(const key_type& __key) { return _M_h.extract(__key); } iterator insert(node_type&& __nh) { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); } # 1870 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator erase(const_iterator __position) { return _M_h.erase(__position); } iterator erase(iterator __position) { return _M_h.erase(__position); } # 1891 "/usr/include/c++/15/bits/unordered_map.h" 3 size_type erase(const key_type& __x) { return _M_h.erase(__x); } # 1910 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_h.erase(__first, __last); } void clear() noexcept { _M_h.clear(); } # 1934 "/usr/include/c++/15/bits/unordered_map.h" 3 void swap(unordered_multimap& __x) noexcept( noexcept(_M_h.swap(__x._M_h)) ) { _M_h.swap(__x._M_h); } template friend class std::_Hash_merge_helper; template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) { if constexpr (is_same_v<_H2, _Hash> && is_same_v<_P2, _Pred>) if (std::__addressof(__source) == this) [[__unlikely__]] return; using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { merge(__source); } hasher hash_function() const { return _M_h.hash_function(); } key_equal key_eq() const { return _M_h.key_eq(); } # 2008 "/usr/include/c++/15/bits/unordered_map.h" 3 iterator find(const key_type& __x) { return _M_h.find(__x); } # 2019 "/usr/include/c++/15/bits/unordered_map.h" 3 const_iterator find(const key_type& __x) const { return _M_h.find(__x); } # 2037 "/usr/include/c++/15/bits/unordered_map.h" 3 size_type count(const key_type& __x) const { return _M_h.count(__x); } # 2075 "/usr/include/c++/15/bits/unordered_map.h" 3 std::pair equal_range(const key_type& __x) { return _M_h.equal_range(__x); } # 2087 "/usr/include/c++/15/bits/unordered_map.h" 3 std::pair equal_range(const key_type& __x) const { return _M_h.equal_range(__x); } # 2103 "/usr/include/c++/15/bits/unordered_map.h" 3 size_type bucket_count() const noexcept { return _M_h.bucket_count(); } size_type max_bucket_count() const noexcept { return _M_h.max_bucket_count(); } size_type bucket_size(size_type __n) const { return _M_h.bucket_size(__n); } size_type bucket(const key_type& __key) const { return _M_h.bucket(__key); } local_iterator begin(size_type __n) { return _M_h.begin(__n); } # 2147 "/usr/include/c++/15/bits/unordered_map.h" 3 const_local_iterator begin(size_type __n) const { return _M_h.begin(__n); } const_local_iterator cbegin(size_type __n) const { return _M_h.cbegin(__n); } # 2162 "/usr/include/c++/15/bits/unordered_map.h" 3 local_iterator end(size_type __n) { return _M_h.end(__n); } # 2173 "/usr/include/c++/15/bits/unordered_map.h" 3 const_local_iterator end(size_type __n) const { return _M_h.end(__n); } const_local_iterator cend(size_type __n) const { return _M_h.cend(__n); } float load_factor() const noexcept { return _M_h.load_factor(); } float max_load_factor() const noexcept { return _M_h.max_load_factor(); } void max_load_factor(float __z) { _M_h.max_load_factor(__z); } # 2210 "/usr/include/c++/15/bits/unordered_map.h" 3 void rehash(size_type __n) { _M_h.rehash(__n); } # 2221 "/usr/include/c++/15/bits/unordered_map.h" 3 void reserve(size_type __n) { _M_h.reserve(__n); } template friend bool operator==(const unordered_multimap<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, const unordered_multimap<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); }; template>, typename _Pred = equal_to<__iter_key_t<_InputIterator>>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, unordered_multimap::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, _Pred, _Allocator>; template, typename _Pred = equal_to<_Key>, typename _Allocator = allocator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_multimap(initializer_list>, unordered_multimap::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, unordered_multimap::size_type, _Allocator) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, _Allocator) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, unordered_multimap::size_type, _Hash, _Allocator) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template> unordered_multimap(initializer_list>, unordered_multimap::size_type, _Allocator) -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template> unordered_multimap(initializer_list>, _Allocator) -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multimap(initializer_list>, unordered_multimap::size_type, _Hash, _Allocator) -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; # 2360 "/usr/include/c++/15/bits/unordered_map.h" 3 template inline void swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline void swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return __x._M_h._M_equal(__y._M_h); } template inline bool operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return !(__x == __y); } template inline bool operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return __x._M_h._M_equal(__y._M_h); } template inline bool operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return !(__x == __y); } template struct _Hash_merge_helper< std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2> { private: template using unordered_map = std::unordered_map<_Tp...>; template using unordered_multimap = std::unordered_multimap<_Tp...>; friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>; static auto& _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } static auto& _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } }; template struct _Hash_merge_helper< std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2> { private: template using unordered_map = std::unordered_map<_Tp...>; template using unordered_multimap = std::unordered_multimap<_Tp...>; friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>; static auto& _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } static auto& _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } }; } # 44 "/usr/include/c++/15/unordered_map" 2 3 # 1 "/usr/include/c++/15/bits/range_access.h" 1 3 # 42 "/usr/include/c++/15/bits/range_access.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto begin(_Container& __cont) noexcept(noexcept(__cont.begin())) -> decltype(__cont.begin()) { return __cont.begin(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto begin(const _Container& __cont) noexcept(noexcept(__cont.begin())) -> decltype(__cont.begin()) { return __cont.begin(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto end(_Container& __cont) noexcept(noexcept(__cont.end())) -> decltype(__cont.end()) { return __cont.end(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto end(const _Container& __cont) noexcept(noexcept(__cont.end())) -> decltype(__cont.end()) { return __cont.end(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr _Tp* begin(_Tp (&__arr)[_Nm]) noexcept { return __arr; } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr _Tp* end(_Tp (&__arr)[_Nm]) noexcept { return __arr + _Nm; } template class valarray; template _Tp* begin(valarray<_Tp>&) noexcept; template const _Tp* begin(const valarray<_Tp>&) noexcept; template _Tp* end(valarray<_Tp>&) noexcept; template const _Tp* end(const valarray<_Tp>&) noexcept; template [[__nodiscard__, __gnu__::__always_inline__]] constexpr auto cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont)) { return std::begin(__cont); } template [[__nodiscard__, __gnu__::__always_inline__]] constexpr auto cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont)) { return std::end(__cont); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto rbegin(_Container& __cont) noexcept(noexcept(__cont.rbegin())) -> decltype(__cont.rbegin()) { return __cont.rbegin(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto rbegin(const _Container& __cont) noexcept(noexcept(__cont.rbegin())) -> decltype(__cont.rbegin()) { return __cont.rbegin(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto rend(_Container& __cont) noexcept(noexcept(__cont.rend())) -> decltype(__cont.rend()) { return __cont.rend(); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto rend(const _Container& __cont) noexcept(noexcept(__cont.rend())) -> decltype(__cont.rend()) { return __cont.rend(); } template [[__nodiscard__]] inline constexpr reverse_iterator<_Tp*> rbegin(_Tp (&__arr)[_Nm]) noexcept { return reverse_iterator<_Tp*>(__arr + _Nm); } template [[__nodiscard__]] inline constexpr reverse_iterator<_Tp*> rend(_Tp (&__arr)[_Nm]) noexcept { return reverse_iterator<_Tp*>(__arr); } template [[__nodiscard__]] inline constexpr reverse_iterator rbegin(initializer_list<_Tp> __il) noexcept { return reverse_iterator(__il.end()); } template [[__nodiscard__]] inline constexpr reverse_iterator rend(initializer_list<_Tp> __il) noexcept { return reverse_iterator(__il.begin()); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto crbegin(const _Container& __cont) noexcept(noexcept(std::rbegin(__cont))) -> decltype(std::rbegin(__cont)) { return std::rbegin(__cont); } template [[__nodiscard__, __gnu__::__always_inline__]] inline constexpr auto crend(const _Container& __cont) noexcept(noexcept(std::rend(__cont))) -> decltype(std::rend(__cont)) { return std::rend(__cont); } # 271 "/usr/include/c++/15/bits/range_access.h" 3 template [[nodiscard, __gnu__::__always_inline__]] constexpr auto size(const _Container& __cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size()) { return __cont.size(); } template [[nodiscard, __gnu__::__always_inline__]] constexpr size_t size(const _Tp (&)[_Nm]) noexcept { return _Nm; } template [[nodiscard, __gnu__::__always_inline__]] constexpr auto empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty()) { return __cont.empty(); } template [[nodiscard, __gnu__::__always_inline__]] constexpr bool empty(const _Tp (&)[_Nm]) noexcept { return false; } template [[nodiscard, __gnu__::__always_inline__]] constexpr bool empty(initializer_list<_Tp> __il) noexcept { return __il.size() == 0;} template [[nodiscard, __gnu__::__always_inline__]] constexpr auto data(_Container& __cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data()) { return __cont.data(); } template [[nodiscard, __gnu__::__always_inline__]] constexpr auto data(const _Container& __cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data()) { return __cont.data(); } template [[nodiscard, __gnu__::__always_inline__]] constexpr _Tp* data(_Tp (&__array)[_Nm]) noexcept { return __array; } template [[nodiscard, __gnu__::__always_inline__]] constexpr const _Tp* data(initializer_list<_Tp> __il) noexcept { return __il.begin(); } # 377 "/usr/include/c++/15/bits/range_access.h" 3 } # 45 "/usr/include/c++/15/unordered_map" 2 3 # 1 "/usr/include/c++/15/bits/erase_if.h" 1 3 # 41 "/usr/include/c++/15/bits/erase_if.h" 3 namespace std { namespace __detail { template typename _Container::size_type __erase_nodes_if(_Container& __cont, _UnsafeContainer& __ucont, _Predicate __pred) { typename _Container::size_type __num = 0; for (auto __iter = __ucont.begin(), __last = __ucont.end(); __iter != __last;) { if (__pred(*__iter)) { __iter = __cont.erase(__iter); ++__num; } else ++__iter; } return __num; } } } # 46 "/usr/include/c++/15/unordered_map" 2 3 # 59 "/usr/include/c++/15/unordered_map" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 60 "/usr/include/c++/15/unordered_map" 2 3 # 1 "/usr/include/c++/15/bits/memory_resource.h" 1 3 # 43 "/usr/include/c++/15/bits/memory_resource.h" 3 # 1 "/usr/include/c++/15/bits/uses_allocator_args.h" 1 3 # 37 "/usr/include/c++/15/bits/uses_allocator_args.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 38 "/usr/include/c++/15/bits/uses_allocator_args.h" 2 3 # 44 "/usr/include/c++/15/bits/memory_resource.h" 2 3 # 52 "/usr/include/c++/15/bits/memory_resource.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { class memory_resource { static constexpr size_t _S_max_align = alignof(max_align_t); public: memory_resource() = default; memory_resource(const memory_resource&) = default; virtual ~memory_resource(); memory_resource& operator=(const memory_resource&) = default; [[nodiscard]] void* allocate(size_t __bytes, size_t __alignment = _S_max_align) __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } void deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) __attribute__((__nonnull__)) { return do_deallocate(__p, __bytes, __alignment); } [[nodiscard]] bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); } private: virtual void* do_allocate(size_t __bytes, size_t __alignment) = 0; virtual void do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; virtual bool do_is_equal(const memory_resource& __other) const noexcept = 0; }; [[nodiscard]] inline bool operator==(const memory_resource& __a, const memory_resource& __b) noexcept { return &__a == &__b || __a.is_equal(__b); } [[nodiscard]] inline bool operator!=(const memory_resource& __a, const memory_resource& __b) noexcept { return !(__a == __b); } # 121 "/usr/include/c++/15/bits/memory_resource.h" 3 template class polymorphic_allocator { template struct __not_pair { using type = void; }; template struct __not_pair> { }; public: using value_type = _Tp; polymorphic_allocator() noexcept { extern memory_resource* get_default_resource() noexcept __attribute__((__returns_nonnull__)); _M_resource = get_default_resource(); } polymorphic_allocator(memory_resource* __r) noexcept __attribute__((__nonnull__)) : _M_resource(__r) { ; } polymorphic_allocator(const polymorphic_allocator& __other) = default; template polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept : _M_resource(__x.resource()) { } polymorphic_allocator& operator=(const polymorphic_allocator&) = delete; [[nodiscard]] _Tp* allocate(size_t __n) __attribute__((__returns_nonnull__)) { if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) std::__throw_bad_array_new_length(); return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), alignof(_Tp))); } void deallocate(_Tp* __p, size_t __n) noexcept __attribute__((__nonnull__)) { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } # 226 "/usr/include/c++/15/bits/memory_resource.h" 3 template __attribute__((__nonnull__)) typename __not_pair<_Tp1>::type construct(_Tp1* __p, _Args&&... __args) { using __use_tag = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) ::new(__p) _Tp1(std::forward<_Args>(__args)...); else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) ::new(__p) _Tp1(allocator_arg, *this, std::forward<_Args>(__args)...); else ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); } template __attribute__((__nonnull__)) void construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, tuple<_Args1...> __x, tuple<_Args2...> __y) { auto __x_tag = __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); auto __y_tag = __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); index_sequence_for<_Args1...> __x_i; index_sequence_for<_Args2...> __y_i; ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, _S_construct_p(__x_tag, __x_i, __x), _S_construct_p(__y_tag, __y_i, __y)); } template __attribute__((__nonnull__)) void construct(pair<_Tp1, _Tp2>* __p) { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } template __attribute__((__nonnull__)) void construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) { this->construct(__p, piecewise_construct, std::forward_as_tuple(std::forward<_Up>(__x)), std::forward_as_tuple(std::forward<_Vp>(__y))); } template __attribute__((__nonnull__)) void construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) { this->construct(__p, piecewise_construct, std::forward_as_tuple(__pr.first), std::forward_as_tuple(__pr.second)); } template __attribute__((__nonnull__)) void construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) { this->construct(__p, piecewise_construct, std::forward_as_tuple(std::forward<_Up>(__pr.first)), std::forward_as_tuple(std::forward<_Vp>(__pr.second))); } # 309 "/usr/include/c++/15/bits/memory_resource.h" 3 template __attribute__((__nonnull__)) void destroy(_Up* __p) { __p->~_Up(); } polymorphic_allocator select_on_container_copy_construction() const noexcept { return polymorphic_allocator(); } memory_resource* resource() const noexcept __attribute__((__returns_nonnull__)) { return _M_resource; } [[nodiscard]] friend bool operator==(const polymorphic_allocator& __a, const polymorphic_allocator& __b) noexcept { return *__a.resource() == *__b.resource(); } [[nodiscard]] friend bool operator!=(const polymorphic_allocator& __a, const polymorphic_allocator& __b) noexcept { return !(__a == __b); } private: using __uses_alloc1_ = __uses_alloc1; using __uses_alloc2_ = __uses_alloc2; template static tuple<_Args&&...> _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) { return std::move(__t); } template static tuple _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, tuple<_Args...>& __t) { return { allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... }; } template static tuple<_Args&&..., polymorphic_allocator> _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, tuple<_Args...>& __t) { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } memory_resource* _M_resource; }; template [[nodiscard]] inline bool operator==(const polymorphic_allocator<_Tp1>& __a, const polymorphic_allocator<_Tp2>& __b) noexcept { return *__a.resource() == *__b.resource(); } template [[nodiscard]] inline bool operator!=(const polymorphic_allocator<_Tp1>& __a, const polymorphic_allocator<_Tp2>& __b) noexcept { return !(__a == __b); } } template struct allocator_traits; template struct allocator_traits> { using allocator_type = pmr::polymorphic_allocator<_Tp>; using value_type = _Tp; using pointer = _Tp*; using const_pointer = const _Tp*; using void_pointer = void*; using const_void_pointer = const void*; using difference_type = std::ptrdiff_t; using size_type = std::size_t; using propagate_on_container_copy_assignment = false_type; using propagate_on_container_move_assignment = false_type; using propagate_on_container_swap = false_type; static allocator_type select_on_container_copy_construction(const allocator_type&) noexcept { return allocator_type(); } using is_always_equal = false_type; template using rebind_alloc = pmr::polymorphic_allocator<_Up>; template using rebind_traits = allocator_traits>; # 452 "/usr/include/c++/15/bits/memory_resource.h" 3 [[nodiscard]] static pointer allocate(allocator_type& __a, size_type __n) { return __a.allocate(__n); } # 467 "/usr/include/c++/15/bits/memory_resource.h" 3 [[nodiscard]] static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer) { return __a.allocate(__n); } # 479 "/usr/include/c++/15/bits/memory_resource.h" 3 static void deallocate(allocator_type& __a, pointer __p, size_type __n) { __a.deallocate(__p, __n); } # 494 "/usr/include/c++/15/bits/memory_resource.h" 3 template static void construct(allocator_type& __a, _Up* __p, _Args&&... __args) { __a.construct(__p, std::forward<_Args>(__args)...); } # 506 "/usr/include/c++/15/bits/memory_resource.h" 3 template static void destroy(allocator_type&, _Up* __p) noexcept(is_nothrow_destructible<_Up>::value) { __p->~_Up(); } static size_type max_size(const allocator_type&) noexcept { return size_t(-1) / sizeof(value_type); } }; } # 63 "/usr/include/c++/15/unordered_map" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template, typename _Pred = std::equal_to<_Key>> using unordered_map = std::unordered_map<_Key, _Tp, _Hash, _Pred, polymorphic_allocator>>; template, typename _Pred = std::equal_to<_Key>> using unordered_multimap = std::unordered_multimap<_Key, _Tp, _Hash, _Pred, polymorphic_allocator>>; } } # 66 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/vector" 1 3 # 67 "/usr/include/c++/15/vector" 3 # 1 "/usr/include/c++/15/bits/stl_uninitialized.h" 1 3 # 71 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _UninitDestroyGuard { explicit _UninitDestroyGuard(_ForwardIterator& __first, _Alloc& __a) : _M_first(__first), _M_cur(__builtin_addressof(__first)), _M_alloc(__a) { } ~_UninitDestroyGuard() { if (__builtin_expect(_M_cur != 0, 0)) std::_Destroy(_M_first, *_M_cur, _M_alloc); } void release() { _M_cur = 0; } private: _ForwardIterator const _M_first; _ForwardIterator* _M_cur; _Alloc& _M_alloc; _UninitDestroyGuard(const _UninitDestroyGuard&); }; template struct _UninitDestroyGuard<_ForwardIterator, void> { explicit _UninitDestroyGuard(_ForwardIterator& __first) : _M_first(__first), _M_cur(__builtin_addressof(__first)) { } ~_UninitDestroyGuard() { if (__builtin_expect(_M_cur != 0, 0)) std::_Destroy(_M_first, *_M_cur); } void release() { _M_cur = 0; } _ForwardIterator const _M_first; _ForwardIterator* _M_cur; private: _UninitDestroyGuard(const _UninitDestroyGuard&); }; template _ForwardIterator __do_uninit_copy(_InputIterator __first, _Sentinel __last, _ForwardIterator __result) { _UninitDestroyGuard<_ForwardIterator> __guard(__result); for (; __first != __last; ++__first, (void)++__result) std::_Construct(std::__addressof(*__result), *__first); __guard.release(); return __result; } # 217 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" # 228 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { # 256 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 using _Dest = decltype(std::__niter_base(__result)); using _Src = decltype(std::__niter_base(__first)); using _ValT = typename iterator_traits<_ForwardIterator>::value_type; if constexpr (!__is_trivially_constructible(_ValT, decltype(*__first))) return std::__do_uninit_copy(__first, __last, __result); else if constexpr (__memcpyable<_Dest, _Src>::__value) { ptrdiff_t __n = __last - __first; if (__n > 0) [[__likely__]] { using _ValT = typename remove_pointer<_Src>::type; __builtin_memcpy(std::__niter_base(__result), std::__niter_base(__first), __n * sizeof(_ValT)); __result += __n; } return __result; } # 302 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 else return std::__do_uninit_copy(__first, __last, __result); # 317 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 } #pragma GCC diagnostic pop template void __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) { _UninitDestroyGuard<_ForwardIterator> __guard(__first); for (; __first != __last; ++__first) std::_Construct(std::__addressof(*__first), __x); __guard.release(); } # 389 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) { # 404 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" if constexpr (__is_byte<_ValueType>::__value) if constexpr (is_same<_ValueType, _Tp>::value || is_integral<_Tp>::value) { using _BasePtr = decltype(std::__niter_base(__first)); if constexpr (is_pointer<_BasePtr>::value) { void* __dest = std::__niter_base(__first); ptrdiff_t __n = __last - __first; if (__n > 0) [[__likely__]] __builtin_memset(__dest, (unsigned char)__x, __n); return; } # 438 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 } std::__do_uninit_fill(__first, __last, __x); #pragma GCC diagnostic pop } template _ForwardIterator __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) { _UninitDestroyGuard<_ForwardIterator> __guard(__first); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" if constexpr (is_integral<_Size>::value) do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); else if constexpr (is_floating_point<_Size>::value) do { if (std::__is_constant_evaluated() && !bool(__n >= 0 && static_cast(__n) == __n)) std::__glibcxx_assert_fail(); } while (false); #pragma GCC diagnostic pop for (; __n--; ++__first) std::_Construct(std::__addressof(*__first), __x); __guard.release(); return __first; } # 510 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" # 523 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; if constexpr (__is_byte<_ValueType>::__value) if constexpr (is_integral<_Tp>::value) if constexpr (is_integral<_Size>::value) { using _BasePtr = decltype(std::__niter_base(__first)); if constexpr (is_pointer<_BasePtr>::value) { void* __dest = std::__niter_base(__first); if (__n > 0) [[__likely__]] { __builtin_memset(__dest, (unsigned char)__x, __n); __first += __n; } return __first; } # 570 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 } return std::__do_uninit_fill_n(__first, __n, __x); # 580 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 } #pragma GCC diagnostic pop # 591 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _Sentinel __last, _ForwardIterator __result, _Allocator& __alloc) { _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result, __alloc); typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __first != __last; ++__first, (void)++__result) __traits::construct(__alloc, std::__addressof(*__result), *__first); __guard.release(); return __result; } template inline _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _Sentinel __last, _ForwardIterator __result, allocator<_Tp>&) { # 637 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 return std::uninitialized_copy(__first, __last, __result); } template inline _ForwardIterator __uninitialized_move_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) { return std::__uninitialized_copy_a(std::make_move_iterator(__first), std::make_move_iterator(__last), __result, __alloc); } template inline _ForwardIterator __uninitialized_move_if_noexcept_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) { return std::__uninitialized_copy_a (std::__make_move_if_noexcept_iterator(__first), std::__make_move_if_noexcept_iterator(__last), __result, __alloc); } template void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, _Allocator& __alloc) { _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first, __alloc); typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __first != __last; ++__first) __traits::construct(__alloc, std::__addressof(*__first), __x); __guard.release(); } template inline void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, allocator<_Tp2>&) { std::uninitialized_fill(__first, __last, __x); } template _ForwardIterator __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, const _Tp& __x, _Allocator& __alloc) { _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first, __alloc); typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __n > 0; --__n, (void) ++__first) __traits::construct(__alloc, std::__addressof(*__first), __x); __guard.release(); return __first; } template inline _ForwardIterator __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, const _Tp& __x, allocator<_Tp2>&) { return std::uninitialized_fill_n(__first, __n, __x); } # 740 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator __uninitialized_copy_move(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator& __alloc) { _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, __result, __alloc); _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result, __alloc); __result = __mid; __result = std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); __guard.release(); return __result; } template inline _ForwardIterator __uninitialized_move_copy(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator& __alloc) { _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, __result, __alloc); _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result, __alloc); __result = __mid; __result = std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); __guard.release(); return __result; } template inline _ForwardIterator __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, const _Tp& __x, _InputIterator __first, _InputIterator __last, _Allocator& __alloc) { std::__uninitialized_fill_a(__result, __mid, __x, __alloc); _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result, __alloc); __result = __mid; __result = std::__uninitialized_move_a(__first, __last, __mid, __alloc); __guard.release(); return __result; } template inline void __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, const _Tp& __x, _Allocator& __alloc) { _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, __first2, __alloc); _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first2, __alloc); __first2 = __mid2; std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); __guard.release(); } # 832 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template struct __uninitialized_default_1 { template static void __uninit_default(_ForwardIterator __first, _ForwardIterator __last) { _UninitDestroyGuard<_ForwardIterator> __guard(__first); for (; __first != __last; ++__first) std::_Construct(std::__addressof(*__first)); __guard.release(); } }; template<> struct __uninitialized_default_1 { template static void __uninit_default(_ForwardIterator __first, _ForwardIterator __last) { if (__first == __last) return; typename iterator_traits<_ForwardIterator>::value_type* __val = std::__addressof(*__first); std::_Construct(__val); if (++__first != __last) std::fill(__first, __last, *__val); } }; template struct __uninitialized_default_n_1 { template static _ForwardIterator __uninit_default_n(_ForwardIterator __first, _Size __n) { _UninitDestroyGuard<_ForwardIterator> __guard(__first); for (; __n > 0; --__n, (void) ++__first) std::_Construct(std::__addressof(*__first)); __guard.release(); return __first; } }; template<> struct __uninitialized_default_n_1 { template static _ForwardIterator __uninit_default_n(_ForwardIterator __first, _Size __n) { if (__n > 0) { typename iterator_traits<_ForwardIterator>::value_type* __val = std::__addressof(*__first); std::_Construct(__val); ++__first; __first = std::fill_n(__first, __n - 1, *__val); } return __first; } }; template inline void __uninitialized_default(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; const bool __assignable = is_copy_assignable<_ValueType>::value; std::__uninitialized_default_1<__is_trivial(_ValueType) && __assignable>:: __uninit_default(__first, __last); } template inline _ForwardIterator __uninitialized_default_n(_ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; constexpr bool __can_fill = __and_, is_copy_assignable<_ValueType>>::value; return __uninitialized_default_n_1<__is_trivial(_ValueType) && __can_fill>:: __uninit_default_n(__first, __n); } template void __uninitialized_default_a(_ForwardIterator __first, _ForwardIterator __last, _Allocator& __alloc) { _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first, __alloc); typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __first != __last; ++__first) __traits::construct(__alloc, std::__addressof(*__first)); __guard.release(); } template inline void __uninitialized_default_a(_ForwardIterator __first, _ForwardIterator __last, allocator<_Tp>&) { std::__uninitialized_default(__first, __last); } template _ForwardIterator __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, _Allocator& __alloc) { _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first, __alloc); typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __n > 0; --__n, (void) ++__first) __traits::construct(__alloc, std::__addressof(*__first)); __guard.release(); return __first; } template inline _ForwardIterator __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, allocator<_Tp>&) { return std::__uninitialized_default_n(__first, __n); } template struct __uninitialized_default_novalue_1 { template static void __uninit_default_novalue(_ForwardIterator __first, _ForwardIterator __last) { _UninitDestroyGuard<_ForwardIterator> __guard(__first); for (; __first != __last; ++__first) std::_Construct_novalue(std::__addressof(*__first)); __guard.release(); } }; template<> struct __uninitialized_default_novalue_1 { template static void __uninit_default_novalue(_ForwardIterator, _ForwardIterator) { } }; template struct __uninitialized_default_novalue_n_1 { template static _ForwardIterator __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) { _UninitDestroyGuard<_ForwardIterator> __guard(__first); for (; __n > 0; --__n, (void) ++__first) std::_Construct_novalue(std::__addressof(*__first)); __guard.release(); return __first; } }; template<> struct __uninitialized_default_novalue_n_1 { template static _ForwardIterator __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) { return std::next(__first, __n); } }; template inline void __uninitialized_default_novalue(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; std::__uninitialized_default_novalue_1< is_trivially_default_constructible<_ValueType>::value>:: __uninit_default_novalue(__first, __last); } template inline _ForwardIterator __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; return __uninitialized_default_novalue_n_1< is_trivially_default_constructible<_ValueType>::value>:: __uninit_default_novalue_n(__first, __n); } template _ForwardIterator __uninitialized_copy_n(_InputIterator __first, _Size __n, _ForwardIterator __result, input_iterator_tag) { _UninitDestroyGuard<_ForwardIterator> __guard(__result); for (; __n > 0; --__n, (void) ++__first, ++__result) std::_Construct(std::__addressof(*__result), *__first); __guard.release(); return __result; } template inline _ForwardIterator __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, _ForwardIterator __result, random_access_iterator_tag) { return std::uninitialized_copy(__first, __first + __n, __result); } template pair<_InputIterator, _ForwardIterator> __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, _ForwardIterator __result, input_iterator_tag) { _UninitDestroyGuard<_ForwardIterator> __guard(__result); for (; __n > 0; --__n, (void) ++__first, ++__result) std::_Construct(std::__addressof(*__result), *__first); __guard.release(); return {__first, __result}; } template inline pair<_RandomAccessIterator, _ForwardIterator> __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, _ForwardIterator __result, random_access_iterator_tag) { auto __second_res = uninitialized_copy(__first, __first + __n, __result); auto __first_res = std::next(__first, __n); return {__first_res, __second_res}; } # 1151 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_copy_n(_InputIterator __first, _Size __n, _ForwardIterator __result) { return std::__uninitialized_copy_n(__first, __n, __result, std::__iterator_category(__first)); } template inline pair<_InputIterator, _ForwardIterator> __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, _ForwardIterator __result) { return std::__uninitialized_copy_n_pair(__first, __n, __result, std::__iterator_category(__first)); } # 1180 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) { std::__uninitialized_default_novalue(__first, __last); } # 1196 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) { return std::__uninitialized_default_novalue_n(__first, __count); } template inline void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) { return std::__uninitialized_default(__first, __last); } # 1226 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) { return std::__uninitialized_default_n(__first, __count); } # 1242 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_move(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { return std::uninitialized_copy (std::make_move_iterator(__first), std::make_move_iterator(__last), __result); } # 1261 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 template inline pair<_InputIterator, _ForwardIterator> uninitialized_move_n(_InputIterator __first, _Size __count, _ForwardIterator __result) { auto __res = std::__uninitialized_copy_n_pair (std::make_move_iterator(__first), __count, __result); return {__res.first.base(), __res.second}; } template inline void __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, _Allocator& __alloc) noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, __dest, std::move(*__orig))) && noexcept(std::allocator_traits<_Allocator>::destroy( __alloc, std::__addressof(*__orig)))) { typedef std::allocator_traits<_Allocator> __traits; __traits::construct(__alloc, __dest, std::move(*__orig)); __traits::destroy(__alloc, std::__addressof(*__orig)); } template struct __is_bitwise_relocatable : __bool_constant<__is_trivial(_Tp)> { }; template inline _ForwardIterator __relocate_a_1(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), std::addressof(*__first), __alloc))) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; static_assert(std::is_same<_ValueType, _ValueType2>::value, "relocation is only possible for values of the same type"); _ForwardIterator __cur = __result; for (; __first != __last; ++__first, (void)++__cur) std::__relocate_object_a(std::__addressof(*__cur), std::__addressof(*__first), __alloc); return __cur; } template inline __enable_if_t::value, _Tp*> __relocate_a_1(_Tp* __first, _Tp* __last, _Tp* __result, [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept { ptrdiff_t __count = __last - __first; if (__count > 0) { # 1343 "/usr/include/c++/15/bits/stl_uninitialized.h" 3 __builtin_memcpy(__result, __first, __count * sizeof(_Tp)); } return __result + __count; } template inline _ForwardIterator __relocate_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result), __alloc))) { return std::__relocate_a_1(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result), __alloc); } } # 68 "/usr/include/c++/15/vector" 2 3 # 1 "/usr/include/c++/15/bits/stl_vector.h" 1 3 # 84 "/usr/include/c++/15/bits/stl_vector.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _Vector_base { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type; typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer pointer; struct _Vector_impl_data { pointer _M_start; pointer _M_finish; pointer _M_end_of_storage; _Vector_impl_data() noexcept : _M_start(), _M_finish(), _M_end_of_storage() { } _Vector_impl_data(_Vector_impl_data&& __x) noexcept : _M_start(__x._M_start), _M_finish(__x._M_finish), _M_end_of_storage(__x._M_end_of_storage) { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); } void _M_copy_data(_Vector_impl_data const& __x) noexcept { _M_start = __x._M_start; _M_finish = __x._M_finish; _M_end_of_storage = __x._M_end_of_storage; } void _M_swap_data(_Vector_impl_data& __x) noexcept { _Vector_impl_data __tmp; __tmp._M_copy_data(*this); _M_copy_data(__x); __x._M_copy_data(__tmp); } }; struct _Vector_impl : public _Tp_alloc_type, public _Vector_impl_data { _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) : _Tp_alloc_type() { } _Vector_impl(_Tp_alloc_type const& __a) noexcept : _Tp_alloc_type(__a) { } _Vector_impl(_Vector_impl&& __x) noexcept : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x)) { } _Vector_impl(_Tp_alloc_type&& __a) noexcept : _Tp_alloc_type(std::move(__a)) { } _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) { } # 300 "/usr/include/c++/15/bits/stl_vector.h" 3 }; public: typedef _Alloc allocator_type; _Tp_alloc_type& _M_get_Tp_allocator() noexcept { return this->_M_impl; } const _Tp_alloc_type& _M_get_Tp_allocator() const noexcept { return this->_M_impl; } allocator_type get_allocator() const noexcept { return allocator_type(_M_get_Tp_allocator()); } _Vector_base() = default; _Vector_base(const allocator_type& __a) noexcept : _M_impl(__a) { } _Vector_base(size_t __n) : _M_impl() { _M_create_storage(__n); } _Vector_base(size_t __n, const allocator_type& __a) : _M_impl(__a) { _M_create_storage(__n); } _Vector_base(_Vector_base&&) = default; _Vector_base(_Tp_alloc_type&& __a) noexcept : _M_impl(std::move(__a)) { } _Vector_base(_Vector_base&& __x, const allocator_type& __a) : _M_impl(__a) { if (__x.get_allocator() == __a) this->_M_impl._M_swap_data(__x._M_impl); else { size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; _M_create_storage(__n); } } _Vector_base(const allocator_type& __a, _Vector_base&& __x) : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) { } ~_Vector_base() noexcept { _M_deallocate(_M_impl._M_start, _M_impl._M_end_of_storage - _M_impl._M_start); } public: _Vector_impl _M_impl; pointer _M_allocate(size_t __n) { typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer(); } void _M_deallocate(pointer __p, size_t __n) { typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; if (__p) _Tr::deallocate(_M_impl, __p, __n); } protected: void _M_create_storage(size_t __n) { this->_M_impl._M_start = this->_M_allocate(__n); this->_M_impl._M_finish = this->_M_impl._M_start; this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; } # 432 "/usr/include/c++/15/bits/stl_vector.h" 3 }; # 457 "/usr/include/c++/15/bits/stl_vector.h" 3 template > class vector : protected _Vector_base<_Tp, _Alloc> { # 470 "/usr/include/c++/15/bits/stl_vector.h" 3 static_assert(is_same::type, _Tp>::value, "std::vector must have a non-const, non-volatile value_type"); typedef _Vector_base<_Tp, _Alloc> _Base; typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; public: typedef _Tp value_type; typedef typename _Base::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef __gnu_cxx::__normal_iterator iterator; typedef __gnu_cxx::__normal_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Alloc allocator_type; private: static constexpr bool _S_nothrow_relocate(true_type) { return noexcept(std::__relocate_a(std::declval(), std::declval(), std::declval(), std::declval<_Tp_alloc_type&>())); } static constexpr bool _S_nothrow_relocate(false_type) { return false; } static constexpr bool _S_use_relocate() { return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{}); } static pointer _S_do_relocate(pointer __first, pointer __last, pointer __result, _Tp_alloc_type& __alloc, true_type) noexcept { return std::__relocate_a(__first, __last, __result, __alloc); } static pointer _S_do_relocate(pointer, pointer, pointer __result, _Tp_alloc_type&, false_type) noexcept { return __result; } static pointer _S_relocate(pointer __first, pointer __last, pointer __result, _Tp_alloc_type& __alloc) noexcept { return std::__relocate_a(__first, __last, __result, __alloc); } protected: using _Base::_M_allocate; using _Base::_M_deallocate; using _Base::_M_impl; using _Base::_M_get_Tp_allocator; public: vector() = default; # 570 "/usr/include/c++/15/bits/stl_vector.h" 3 explicit vector(const allocator_type& __a) noexcept : _Base(__a) { } # 584 "/usr/include/c++/15/bits/stl_vector.h" 3 explicit vector(size_type __n, const allocator_type& __a = allocator_type()) : _Base(_S_check_init_len(__n, __a), __a) { _M_default_initialize(__n); } # 598 "/usr/include/c++/15/bits/stl_vector.h" 3 vector(size_type __n, const value_type& __value, const allocator_type& __a = allocator_type()) : _Base(_S_check_init_len(__n, __a), __a) { _M_fill_initialize(__n, __value); } # 630 "/usr/include/c++/15/bits/stl_vector.h" 3 vector(const vector& __x) : _Base(__x.size(), _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) { this->_M_impl._M_finish = std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); } # 650 "/usr/include/c++/15/bits/stl_vector.h" 3 vector(vector&&) noexcept = default; vector(const vector& __x, const __type_identity_t& __a) : _Base(__x.size(), __a) { this->_M_impl._M_finish = std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); } private: vector(vector&& __rv, const allocator_type& __m, true_type) noexcept : _Base(__m, std::move(__rv)) { } vector(vector&& __rv, const allocator_type& __m, false_type) : _Base(__m) { if (__rv.get_allocator() == __m) this->_M_impl._M_swap_data(__rv._M_impl); else if (!__rv.empty()) { this->_M_create_storage(__rv.size()); this->_M_impl._M_finish = std::__uninitialized_move_a(__rv.begin(), __rv.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); __rv.clear(); } } public: vector(vector&& __rv, const __type_identity_t& __m) noexcept( noexcept( vector(std::declval(), std::declval(), std::declval())) ) : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{}) { } # 707 "/usr/include/c++/15/bits/stl_vector.h" 3 vector(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_range_initialize_n(__l.begin(), __l.end(), __l.size()); } # 733 "/usr/include/c++/15/bits/stl_vector.h" 3 template> vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a = allocator_type()) : _Base(__a) { # 751 "/usr/include/c++/15/bits/stl_vector.h" 3 _M_range_initialize(__first, __last, std::__iterator_category(__first)); } # 799 "/usr/include/c++/15/bits/stl_vector.h" 3 ~vector() noexcept { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; } # 816 "/usr/include/c++/15/bits/stl_vector.h" 3 vector& operator=(const vector& __x); # 831 "/usr/include/c++/15/bits/stl_vector.h" 3 vector& operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) { constexpr bool __move_storage = _Alloc_traits::_S_propagate_on_move_assign() || _Alloc_traits::_S_always_equal(); _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); return *this; } # 853 "/usr/include/c++/15/bits/stl_vector.h" 3 vector& operator=(initializer_list __l) { this->_M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); return *this; } # 873 "/usr/include/c++/15/bits/stl_vector.h" 3 void assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } # 891 "/usr/include/c++/15/bits/stl_vector.h" 3 template> void assign(_InputIterator __first, _InputIterator __last) { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } # 920 "/usr/include/c++/15/bits/stl_vector.h" 3 void assign(initializer_list __l) { this->_M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } # 988 "/usr/include/c++/15/bits/stl_vector.h" 3 using _Base::get_allocator; [[__nodiscard__]] iterator begin() noexcept { return iterator(this->_M_impl._M_start); } [[__nodiscard__]] const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_start); } [[__nodiscard__]] iterator end() noexcept { return iterator(this->_M_impl._M_finish); } [[__nodiscard__]] const_iterator end() const noexcept { return const_iterator(this->_M_impl._M_finish); } [[__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 const_iterator(this->_M_impl._M_start); } [[__nodiscard__]] const_iterator cend() const noexcept { return const_iterator(this->_M_impl._M_finish); } [[__nodiscard__]] const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } [[__nodiscard__]] const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } [[__nodiscard__]] size_type size() const noexcept { ptrdiff_t __dif = this->_M_impl._M_finish - this->_M_impl._M_start; if (__dif < 0) __builtin_unreachable (); return size_type(__dif); } [[__nodiscard__]] size_type max_size() const noexcept { return _S_max_size(_M_get_Tp_allocator()); } # 1141 "/usr/include/c++/15/bits/stl_vector.h" 3 void resize(size_type __new_size) { if (__new_size > size()) _M_default_append(__new_size - size()); else if (__new_size < size()) _M_erase_at_end(this->_M_impl._M_start + __new_size); } # 1162 "/usr/include/c++/15/bits/stl_vector.h" 3 void resize(size_type __new_size, const value_type& __x) { if (__new_size > size()) _M_fill_insert(end(), __new_size - size(), __x); else if (__new_size < size()) _M_erase_at_end(this->_M_impl._M_start + __new_size); } # 1196 "/usr/include/c++/15/bits/stl_vector.h" 3 void shrink_to_fit() { _M_shrink_to_fit(); } [[__nodiscard__]] size_type capacity() const noexcept { ptrdiff_t __dif = this->_M_impl._M_end_of_storage - this->_M_impl._M_start; if (__dif < 0) __builtin_unreachable (); return size_type(__dif); } [[__nodiscard__]] bool empty() const noexcept { return begin() == end(); } # 1243 "/usr/include/c++/15/bits/stl_vector.h" 3 void reserve(size_type __n); # 1259 "/usr/include/c++/15/bits/stl_vector.h" 3 [[__nodiscard__]] reference operator[](size_type __n) noexcept { do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false); return *(this->_M_impl._M_start + __n); } # 1278 "/usr/include/c++/15/bits/stl_vector.h" 3 [[__nodiscard__]] const_reference operator[](size_type __n) const noexcept { do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false); return *(this->_M_impl._M_start + __n); } protected: void _M_range_check(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); } public: # 1311 "/usr/include/c++/15/bits/stl_vector.h" 3 [[__nodiscard__]] reference at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } # 1330 "/usr/include/c++/15/bits/stl_vector.h" 3 [[__nodiscard__]] const_reference at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } [[__nodiscard__]] reference front() noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *begin(); } [[__nodiscard__]] const_reference front() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *begin(); } [[__nodiscard__]] reference back() noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *(end() - 1); } [[__nodiscard__]] const_reference back() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *(end() - 1); } # 1393 "/usr/include/c++/15/bits/stl_vector.h" 3 [[__nodiscard__]] _Tp* data() noexcept { return _M_data_ptr(this->_M_impl._M_start); } [[__nodiscard__]] const _Tp* data() const noexcept { return _M_data_ptr(this->_M_impl._M_start); } # 1414 "/usr/include/c++/15/bits/stl_vector.h" 3 void push_back(const value_type& __x) { if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x); ++this->_M_impl._M_finish; ; } else _M_realloc_append(__x); } void push_back(value_type&& __x) { emplace_back(std::move(__x)); } template reference emplace_back(_Args&&... __args); # 1455 "/usr/include/c++/15/bits/stl_vector.h" 3 void pop_back() noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); --this->_M_impl._M_finish; _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); ; } # 1478 "/usr/include/c++/15/bits/stl_vector.h" 3 template iterator emplace(const_iterator __position, _Args&&... __args) { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } # 1495 "/usr/include/c++/15/bits/stl_vector.h" 3 iterator insert(const_iterator __position, const value_type& __x); # 1526 "/usr/include/c++/15/bits/stl_vector.h" 3 iterator insert(const_iterator __position, value_type&& __x) { return _M_insert_rval(__position, std::move(__x)); } # 1544 "/usr/include/c++/15/bits/stl_vector.h" 3 iterator insert(const_iterator __position, initializer_list __l) { auto __offset = __position - cbegin(); _M_range_insert(begin() + __offset, __l.begin(), __l.end(), std::random_access_iterator_tag()); return begin() + __offset; } # 1570 "/usr/include/c++/15/bits/stl_vector.h" 3 iterator insert(const_iterator __position, size_type __n, const value_type& __x) { difference_type __offset = __position - cbegin(); _M_fill_insert(begin() + __offset, __n, __x); return begin() + __offset; } # 1613 "/usr/include/c++/15/bits/stl_vector.h" 3 template> iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { difference_type __offset = __position - cbegin(); _M_range_insert(begin() + __offset, __first, __last, std::__iterator_category(__first)); return begin() + __offset; } # 1789 "/usr/include/c++/15/bits/stl_vector.h" 3 iterator erase(const_iterator __position) { return _M_erase(begin() + (__position - cbegin())); } # 1817 "/usr/include/c++/15/bits/stl_vector.h" 3 iterator erase(const_iterator __first, const_iterator __last) { const auto __beg = begin(); const auto __cbeg = cbegin(); return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); } # 1842 "/usr/include/c++/15/bits/stl_vector.h" 3 void swap(vector& __x) noexcept { do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) std::__glibcxx_assert_fail(); } while (false) ; this->_M_impl._M_swap_data(__x._M_impl); _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } void clear() noexcept { _M_erase_at_end(this->_M_impl._M_start); } private: struct _Guard_alloc { pointer _M_storage; size_type _M_len; _Base& _M_vect; _Guard_alloc(pointer __s, size_type __l, _Base& __vect) : _M_storage(__s), _M_len(__l), _M_vect(__vect) { } ~_Guard_alloc() { if (_M_storage) _M_vect._M_deallocate(_M_storage, _M_len); } pointer _M_release() { pointer __res = _M_storage; _M_storage = pointer(); return __res; } private: _Guard_alloc(const _Guard_alloc&); }; protected: template pointer _M_allocate_and_copy(size_type __n, _ForwardIterator __first, _ForwardIterator __last) { _Guard_alloc __guard(this->_M_allocate(__n), __n, *this); std::__uninitialized_copy_a (__first, __last, __guard._M_storage, _M_get_Tp_allocator()); return __guard._M_release(); } # 1948 "/usr/include/c++/15/bits/stl_vector.h" 3 template void _M_range_initialize(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { try { for (; __first != __last; ++__first) emplace_back(*__first); } catch(...) { clear(); throw; } } template void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { _M_range_initialize_n(__first, __last, std::distance(__first, __last)); } template void _M_range_initialize_n(_Iterator __first, _Sentinel __last, size_type __n) { pointer __start = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); this->_M_impl._M_start = this->_M_impl._M_finish = __start; this->_M_impl._M_end_of_storage = __start + __n; this->_M_impl._M_finish = std::__uninitialized_copy_a(std::move(__first), __last, __start, _M_get_Tp_allocator()); } void _M_fill_initialize(size_type __n, const value_type& __value) { this->_M_impl._M_finish = std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, _M_get_Tp_allocator()); } void _M_default_initialize(size_type __n) { this->_M_impl._M_finish = std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, _M_get_Tp_allocator()); } # 2023 "/usr/include/c++/15/bits/stl_vector.h" 3 template void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) { _M_fill_assign(__n, __val); } template void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } template void _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_fill_assign(size_type __n, const value_type& __val); template void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, __true_type) { _M_fill_insert(__pos, __n, __val); } template void _M_insert_dispatch(iterator __pos, _InputIterator __first, _InputIterator __last, __false_type) { _M_range_insert(__pos, __first, __last, std::__iterator_category(__first)); } template void _M_range_insert(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_range_insert(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); void _M_default_append(size_type __n); bool _M_shrink_to_fit(); # 2125 "/usr/include/c++/15/bits/stl_vector.h" 3 struct _Temporary_value { template explicit _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec) { _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), std::forward<_Args>(__args)...); } ~_Temporary_value() { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } value_type& _M_val() noexcept { return _M_storage._M_val; } private: _Tp* _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); } union _Storage { constexpr _Storage() : _M_byte() { } ~_Storage() { } _Storage& operator=(const _Storage&) = delete; unsigned char _M_byte; _Tp _M_val; }; vector* _M_this; _Storage _M_storage; }; template void _M_insert_aux(iterator __position, _Arg&& __arg); template void _M_realloc_insert(iterator __position, _Args&&... __args); template void _M_realloc_append(_Args&&... __args); iterator _M_insert_rval(const_iterator __position, value_type&& __v); template iterator _M_emplace_aux(const_iterator __position, _Args&&... __args); iterator _M_emplace_aux(const_iterator __position, value_type&& __v) { return _M_insert_rval(__position, std::move(__v)); } size_type _M_check_len(size_type __n, const char* __s) const { if (max_size() - size() < __n) __throw_length_error((__s)); const size_type __len = size() + (std::max)(size(), __n); return (__len < size() || __len > max_size()) ? max_size() : __len; } static size_type _S_check_init_len(size_type __n, const allocator_type& __a) { if (__n > _S_max_size(_Tp_alloc_type(__a))) __throw_length_error( ("cannot create std::vector larger than max_size()")); return __n; } static size_type _S_max_size(const _Tp_alloc_type& __a) noexcept { const size_t __diffmax = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); const size_t __allocmax = _Alloc_traits::max_size(__a); return (std::min)(__diffmax, __allocmax); } void _M_erase_at_end(pointer __pos) noexcept { if (size_type __n = this->_M_impl._M_finish - __pos) { std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __pos; ; } } iterator _M_erase(iterator __position); iterator _M_erase(iterator __first, iterator __last); private: void _M_move_assign(vector&& __x, true_type) noexcept { vector __tmp(get_allocator()); this->_M_impl._M_swap_data(__x._M_impl); __tmp._M_impl._M_swap_data(__x._M_impl); std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } void _M_move_assign(vector&& __x, false_type) { if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) _M_move_assign(std::move(__x), true_type()); else { this->_M_assign_aux(std::make_move_iterator(__x.begin()), std::make_move_iterator(__x.end()), std::random_access_iterator_tag()); __x.clear(); } } template _Up* _M_data_ptr(_Up* __ptr) const noexcept { return __ptr; } template typename std::pointer_traits<_Ptr>::element_type* _M_data_ptr(_Ptr __ptr) const { return empty() ? nullptr : std::__to_address(__ptr); } }; template::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>> vector(_InputIterator, _InputIterator, _Allocator = _Allocator()) -> vector<_ValT, _Allocator>; # 2335 "/usr/include/c++/15/bits/stl_vector.h" 3 template [[__nodiscard__]] inline bool operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return (__x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin())); } # 2375 "/usr/include/c++/15/bits/stl_vector.h" 3 template [[__nodiscard__]] inline bool operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template [[__nodiscard__]] inline bool operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return !(__x == __y); } template [[__nodiscard__]] inline bool operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return __y < __x; } template [[__nodiscard__]] inline bool operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline bool operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return !(__x < __y); } template inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::is_nothrow_move_assignable> { }; } } # 69 "/usr/include/c++/15/vector" 2 3 # 1 "/usr/include/c++/15/bits/stl_bvector.h" 1 3 # 68 "/usr/include/c++/15/bits/stl_bvector.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { typedef unsigned long _Bit_type; enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; __attribute__((__nonnull__)) void __fill_bvector_n(_Bit_type*, size_t, bool) noexcept; struct _Bit_reference { private: template friend class vector; friend struct _Bit_iterator; friend struct _Bit_const_iterator; _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } _Bit_type * _M_p; _Bit_type _M_mask; _Bit_reference(_Bit_type * __x, _Bit_type __y) : _M_p(__x), _M_mask(__y) { } public: _Bit_reference(const _Bit_reference&) = default; [[__nodiscard__]] operator bool() const noexcept { return !!(*_M_p & _M_mask); } _Bit_reference& operator=(bool __x) noexcept { if (__x) *_M_p |= _M_mask; else *_M_p &= ~_M_mask; return *this; } # 131 "/usr/include/c++/15/bits/stl_bvector.h" 3 _Bit_reference& operator=(const _Bit_reference& __x) noexcept { return *this = bool(__x); } [[__nodiscard__]] bool operator==(const _Bit_reference& __x) const { return bool(*this) == bool(__x); } [[__nodiscard__]] bool operator<(const _Bit_reference& __x) const { return !bool(*this) && bool(__x); } void flip() noexcept { *_M_p ^= _M_mask; } friend void swap(_Bit_reference __x, _Bit_reference __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } friend void swap(_Bit_reference __x, bool& __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } friend void swap(bool& __x, _Bit_reference __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" struct _Bit_iterator_base : public std::iterator { _Bit_type * _M_p; unsigned int _M_offset; inline __attribute__((__always_inline__)) void _M_assume_normalized() const { unsigned int __ofst = _M_offset; __attribute__ ((__assume__ (__ofst < unsigned(_S_word_bit)))); } _Bit_iterator_base(_Bit_type * __x, unsigned int __y) : _M_p(__x), _M_offset(__y) { } void _M_bump_up() { _M_assume_normalized(); if (_M_offset++ == int(_S_word_bit) - 1) { _M_offset = 0; ++_M_p; } } void _M_bump_down() { _M_assume_normalized(); if (_M_offset-- == 0) { _M_offset = int(_S_word_bit) - 1; --_M_p; } } void _M_incr(ptrdiff_t __i) { _M_assume_normalized(); difference_type __n = __i + _M_offset; _M_p += __n / int(_S_word_bit); __n = __n % int(_S_word_bit); if (__n < 0) { __n += int(_S_word_bit); --_M_p; } _M_offset = static_cast(__n); } [[__nodiscard__]] friend bool operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { __x._M_assume_normalized(); __y._M_assume_normalized(); return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } # 266 "/usr/include/c++/15/bits/stl_bvector.h" 3 [[__nodiscard__]] friend bool operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { __x._M_assume_normalized(); __y._M_assume_normalized(); return __x._M_p < __y._M_p || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset); } [[__nodiscard__]] friend bool operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { return !(__x == __y); } [[__nodiscard__]] friend bool operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { return __y < __x; } [[__nodiscard__]] friend bool operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { return !(__y < __x); } [[__nodiscard__]] friend bool operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { return !(__x < __y); } friend ptrdiff_t operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { __x._M_assume_normalized(); __y._M_assume_normalized(); return (int(_S_word_bit) * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset); } }; #pragma GCC diagnostic pop struct _Bit_iterator : public _Bit_iterator_base { typedef _Bit_reference reference; typedef _Bit_reference* pointer; typedef _Bit_iterator iterator; _Bit_iterator() : _Bit_iterator_base(0, 0) { } _Bit_iterator(_Bit_type * __x, unsigned int __y) : _Bit_iterator_base(__x, __y) { } iterator _M_const_cast() const { return *this; } [[__nodiscard__]] reference operator*() const { _M_assume_normalized(); return reference(_M_p, 1UL << _M_offset); } iterator& operator++() { _M_bump_up(); return *this; } iterator operator++(int) { iterator __tmp = *this; _M_bump_up(); return __tmp; } iterator& operator--() { _M_bump_down(); return *this; } iterator operator--(int) { iterator __tmp = *this; _M_bump_down(); return __tmp; } iterator& operator+=(difference_type __i) { _M_incr(__i); return *this; } iterator& operator-=(difference_type __i) { *this += -__i; return *this; } [[__nodiscard__]] reference operator[](difference_type __i) const { return *(*this + __i); } [[__nodiscard__]] friend iterator operator+(const iterator& __x, difference_type __n) { iterator __tmp = __x; __tmp += __n; return __tmp; } [[__nodiscard__]] friend iterator operator+(difference_type __n, const iterator& __x) { return __x + __n; } [[__nodiscard__]] friend iterator operator-(const iterator& __x, difference_type __n) { iterator __tmp = __x; __tmp -= __n; return __tmp; } }; struct _Bit_const_iterator : public _Bit_iterator_base { typedef bool reference; typedef bool const_reference; typedef const bool* pointer; typedef _Bit_const_iterator const_iterator; _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } _Bit_const_iterator(_Bit_type * __x, unsigned int __y) : _Bit_iterator_base(__x, __y) { } _Bit_const_iterator(const _Bit_iterator& __x) : _Bit_iterator_base(__x._M_p, __x._M_offset) { } _Bit_iterator _M_const_cast() const { return _Bit_iterator(_M_p, _M_offset); } [[__nodiscard__]] const_reference operator*() const { _M_assume_normalized(); return _Bit_reference(_M_p, 1UL << _M_offset); } const_iterator& operator++() { _M_bump_up(); return *this; } const_iterator operator++(int) { const_iterator __tmp = *this; _M_bump_up(); return __tmp; } const_iterator& operator--() { _M_bump_down(); return *this; } const_iterator operator--(int) { const_iterator __tmp = *this; _M_bump_down(); return __tmp; } const_iterator& operator+=(difference_type __i) { _M_incr(__i); return *this; } const_iterator& operator-=(difference_type __i) { *this += -__i; return *this; } [[__nodiscard__]] const_reference operator[](difference_type __i) const { return *(*this + __i); } [[__nodiscard__]] friend const_iterator operator+(const const_iterator& __x, difference_type __n) { const_iterator __tmp = __x; __tmp += __n; return __tmp; } [[__nodiscard__]] friend const_iterator operator-(const const_iterator& __x, difference_type __n) { const_iterator __tmp = __x; __tmp -= __n; return __tmp; } [[__nodiscard__]] friend const_iterator operator+(difference_type __n, const const_iterator& __x) { return __x + __n; } }; template struct _Bvector_base { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Bit_type>::other _Bit_alloc_type; typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type> _Bit_alloc_traits; typedef typename _Bit_alloc_traits::pointer _Bit_pointer; struct _Bvector_impl_data { _Bit_iterator _M_start; # 553 "/usr/include/c++/15/bits/stl_bvector.h" 3 _Bit_iterator _M_finish; _Bit_pointer _M_end_of_storage; _Bvector_impl_data() noexcept : _M_start(), _M_finish(), _M_end_of_storage() { } _Bvector_impl_data(const _Bvector_impl_data&) = default; _Bvector_impl_data& operator=(const _Bvector_impl_data&) = default; _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept : _Bvector_impl_data(__x) { __x._M_reset(); } void _M_move_data(_Bvector_impl_data&& __x) noexcept { *this = __x; __x._M_reset(); } void _M_reset() noexcept { *this = _Bvector_impl_data(); } void _M_swap_data(_Bvector_impl_data& __x) noexcept { std::swap(*this, __x); } }; struct _Bvector_impl : public _Bit_alloc_type, public _Bvector_impl_data { _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value) : _Bit_alloc_type() { } _Bvector_impl(const _Bit_alloc_type& __a) noexcept : _Bit_alloc_type(__a) { } _Bvector_impl(_Bvector_impl&& __x) noexcept : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x)) { } _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x)) { } _Bit_type* _M_end_addr() const noexcept { if (this->_M_end_of_storage) return std::__addressof(this->_M_end_of_storage[-1]) + 1; return 0; } }; public: typedef _Alloc allocator_type; _Bit_alloc_type& _M_get_Bit_allocator() noexcept { return this->_M_impl; } const _Bit_alloc_type& _M_get_Bit_allocator() const noexcept { return this->_M_impl; } allocator_type get_allocator() const noexcept { return allocator_type(_M_get_Bit_allocator()); } _Bvector_base() = default; _Bvector_base(const allocator_type& __a) : _M_impl(_Bit_alloc_type(__a)) { } _Bvector_base(_Bvector_base&&) = default; _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl)) { } ~_Bvector_base() { this->_M_deallocate(); } protected: _Bvector_impl _M_impl; _Bit_pointer _M_allocate(size_t __n) { _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); # 694 "/usr/include/c++/15/bits/stl_bvector.h" 3 return __p; } void _M_deallocate() { if (_M_impl._M_start._M_p) { const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p; _Bit_alloc_traits::deallocate(_M_impl, _M_impl._M_end_of_storage - __n, __n); _M_impl._M_reset(); } } void _M_move_data(_Bvector_base&& __x) noexcept { _M_impl._M_move_data(std::move(__x._M_impl)); } constexpr static size_t _S_nword(size_t __n) { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } }; # 745 "/usr/include/c++/15/bits/stl_bvector.h" 3 template class vector : protected _Bvector_base<_Alloc> { typedef _Bvector_base<_Alloc> _Base; typedef typename _Base::_Bit_pointer _Bit_pointer; typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits; friend struct std::hash; public: typedef bool value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Bit_reference reference; typedef bool const_reference; typedef _Bit_reference* pointer; typedef const bool* const_pointer; typedef _Bit_iterator iterator; typedef _Bit_const_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; typedef _Alloc allocator_type; allocator_type get_allocator() const { return _Base::get_allocator(); } protected: using _Base::_M_allocate; using _Base::_M_deallocate; using _Base::_S_nword; using _Base::_M_get_Bit_allocator; public: vector() = default; explicit vector(const allocator_type& __a) noexcept : _Base(__a) { } explicit vector(size_type __n, const allocator_type& __a = allocator_type()) : vector(__n, false, __a) { } vector(size_type __n, const bool& __value, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_initialize(__n); _M_initialize_value(__value); } vector(const vector& __x) : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator())) { const_iterator __xbegin = __x.begin(), __xend = __x.end(); _M_initialize(__x.size()); _M_copy_aligned(__xbegin, __xend, begin()); } vector(vector&&) = default; private: vector(vector&& __x, const allocator_type& __a, true_type) noexcept : _Base(std::move(__x), __a) { } vector(vector&& __x, const allocator_type& __a, false_type) : _Base(__a) { if (__x.get_allocator() == __a) this->_M_move_data(std::move(__x)); else { _M_initialize(__x.size()); _M_copy_aligned(__x.begin(), __x.end(), begin()); __x.clear(); } } public: vector(vector&& __x, const __type_identity_t& __a) noexcept(_Bit_alloc_traits::_S_always_equal()) : vector(std::move(__x), __a, typename _Bit_alloc_traits::is_always_equal{}) { } vector(const vector& __x, const __type_identity_t& __a) : _Base(__a) { _M_initialize(__x.size()); _M_copy_aligned(__x.begin(), __x.end(), begin()); } vector(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_initialize_range(__l.begin(), __l.end(), random_access_iterator_tag()); } template> vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_initialize_range(__first, __last, std::__iterator_category(__first)); } # 925 "/usr/include/c++/15/bits/stl_bvector.h" 3 ~vector() noexcept { } vector& operator=(const vector& __x) { if (&__x == this) return *this; if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) { if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator()) { this->_M_deallocate(); std::__alloc_on_copy(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); _M_initialize(__x.size()); } else std::__alloc_on_copy(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); } if (__x.size() > capacity()) { this->_M_deallocate(); _M_initialize(__x.size()); } this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), begin()); return *this; } vector& operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move()) { if (_Bit_alloc_traits::_S_propagate_on_move_assign() || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator()) { this->_M_deallocate(); this->_M_move_data(std::move(__x)); std::__alloc_on_move(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); } else { if (__x.size() > capacity()) { this->_M_deallocate(); _M_initialize(__x.size()); } this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), begin()); __x.clear(); } return *this; } vector& operator=(initializer_list __l) { this->assign(__l.begin(), __l.end()); return *this; } void assign(size_type __n, const bool& __x) { _M_fill_assign(__n, __x); } template> void assign(_InputIterator __first, _InputIterator __last) { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } # 1023 "/usr/include/c++/15/bits/stl_bvector.h" 3 void assign(initializer_list __l) { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } # 1063 "/usr/include/c++/15/bits/stl_bvector.h" 3 [[__nodiscard__]] iterator begin() noexcept { return iterator(this->_M_impl._M_start._M_p, 0); } [[__nodiscard__]] const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_start._M_p, 0); } [[__nodiscard__]] iterator end() noexcept { return this->_M_impl._M_finish; } [[__nodiscard__]] const_iterator end() const noexcept { return this->_M_impl._M_finish; } [[__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 const_iterator(this->_M_impl._M_start._M_p, 0); } [[__nodiscard__]] const_iterator cend() const noexcept { return this->_M_impl._M_finish; } [[__nodiscard__]] const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } [[__nodiscard__]] const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } [[__nodiscard__]] size_type size() const noexcept { return size_type(end() - begin()); } [[__nodiscard__]] size_type max_size() const noexcept { const size_type __isize = __gnu_cxx::__numeric_traits::__max - int(_S_word_bit) + 1; const size_type __asize = _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); return (__asize <= __isize / int(_S_word_bit) ? __asize * int(_S_word_bit) : __isize); } [[__nodiscard__]] size_type capacity() const noexcept { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0) - begin()); } [[__nodiscard__]] bool empty() const noexcept { return begin() == end(); } [[__nodiscard__]] reference operator[](size_type __n) { do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false); return _Bit_reference (this->_M_impl._M_start._M_p + __n / int(_S_word_bit), 1UL << __n % int(_S_word_bit)); } [[__nodiscard__]] const_reference operator[](size_type __n) const { do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false); return _Bit_reference (this->_M_impl._M_start._M_p + __n / int(_S_word_bit), 1UL << __n % int(_S_word_bit)); } protected: void _M_range_check(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); } public: [[__nodiscard__]] reference at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } [[__nodiscard__]] const_reference at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } void reserve(size_type __n) { if (__n > max_size()) __throw_length_error(("vector::reserve")); if (capacity() < __n) _M_reallocate(__n); } [[__nodiscard__]] reference front() { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *begin(); } [[__nodiscard__]] const_reference front() const { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *begin(); } [[__nodiscard__]] reference back() { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *(end() - 1); } [[__nodiscard__]] const_reference back() const { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return *(end() - 1); } void push_back(bool __x) { if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) *this->_M_impl._M_finish++ = __x; else _M_insert_aux(end(), __x); } void swap(vector& __x) noexcept { do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator())) std::__glibcxx_assert_fail(); } while (false) ; this->_M_impl._M_swap_data(__x._M_impl); _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); } static void swap(reference __x, reference __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } iterator insert(const_iterator __position, const bool& __x) { const difference_type __n = __position - begin(); if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr() && __position == end()) *this->_M_impl._M_finish++ = __x; else _M_insert_aux(__position._M_const_cast(), __x); return begin() + __n; } __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead"))) iterator insert(const_iterator __position) { return this->insert(__position._M_const_cast(), false); } template> iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { difference_type __offset = __position - cbegin(); _M_insert_range(__position._M_const_cast(), __first, __last, std::__iterator_category(__first)); return begin() + __offset; } # 1329 "/usr/include/c++/15/bits/stl_bvector.h" 3 iterator insert(const_iterator __position, size_type __n, const bool& __x) { difference_type __offset = __position - cbegin(); _M_fill_insert(__position._M_const_cast(), __n, __x); return begin() + __offset; } iterator insert(const_iterator __p, initializer_list __l) { return this->insert(__p, __l.begin(), __l.end()); } # 1463 "/usr/include/c++/15/bits/stl_bvector.h" 3 void pop_back() { --this->_M_impl._M_finish; } iterator erase(const_iterator __position) { return _M_erase(__position._M_const_cast()); } iterator erase(const_iterator __first, const_iterator __last) { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } void resize(size_type __new_size, bool __x = bool()) { if (__new_size < size()) _M_erase_at_end(begin() + difference_type(__new_size)); else insert(end(), __new_size - size(), __x); } void shrink_to_fit() { _M_shrink_to_fit(); } void flip() noexcept { _Bit_type * const __end = this->_M_impl._M_end_addr(); for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p) *__p = ~*__p; } void clear() noexcept { _M_erase_at_end(begin()); } template reference emplace_back(_Args&&... __args) { push_back(bool(std::forward<_Args>(__args)...)); return back(); } template iterator emplace(const_iterator __pos, _Args&&... __args) { return insert(__pos, bool(std::forward<_Args>(__args)...)); } protected: iterator _M_copy_aligned(const_iterator __first, const_iterator __last, iterator __result) { _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); return std::copy(const_iterator(__last._M_p, 0), __last, iterator(__q, 0)); } void _M_initialize(size_type __n) { if (__n) { _Bit_pointer __q = this->_M_allocate(__n); this->_M_impl._M_end_of_storage = __q + _S_nword(__n); iterator __start = iterator(std::__addressof(*__q), 0); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __start + difference_type(__n); } } void _M_initialize_value(bool __x) noexcept { if (_Bit_type* __p = this->_M_impl._M_start._M_p) __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x); } void _M_reallocate(size_type __n); bool _M_shrink_to_fit(); # 1603 "/usr/include/c++/15/bits/stl_bvector.h" 3 template void _M_initialize_range(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) push_back(*__first); } template void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); _M_initialize(__n); std::copy(__first, __last, begin()); } # 1639 "/usr/include/c++/15/bits/stl_bvector.h" 3 void _M_fill_assign(size_t __n, bool __x) { if (__n > size()) { _M_initialize_value(__x); insert(end(), __n - size(), __x); } else { _M_erase_at_end(begin() + __n); _M_initialize_value(__x); } } template void _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { iterator __cur = begin(); for (; __first != __last && __cur != end(); ++__cur, (void)++__first) *__cur = *__first; if (__first == __last) _M_erase_at_end(__cur); else insert(end(), __first, __last); } template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); if (__len < size()) _M_erase_at_end(std::copy(__first, __last, begin())); else { _ForwardIterator __mid = __first; std::advance(__mid, size()); std::copy(__first, __mid, begin()); insert(end(), __mid, __last); } } # 1706 "/usr/include/c++/15/bits/stl_bvector.h" 3 void _M_fill_insert(iterator __position, size_type __n, bool __x); template void _M_insert_range(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) { __pos = insert(__pos, *__first); ++__pos; } } template void _M_insert_range(iterator __position, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_insert_aux(iterator __position, bool __x); size_type _M_check_len(size_type __n, const char* __s) const { if (max_size() - size() < __n) __throw_length_error((__s)); const size_type __len = size() + std::max(size(), __n); return (__len < size() || __len > max_size()) ? max_size() : __len; } void _M_erase_at_end(iterator __pos) { this->_M_impl._M_finish = __pos; } iterator _M_erase(iterator __pos); iterator _M_erase(iterator __first, iterator __last); protected: void data() = delete; }; inline void __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last, bool __x) noexcept { const _Bit_type __fmask = ~0ul << __first; const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last); const _Bit_type __mask = __fmask & __lmask; if (__x) *__v |= __mask; else *__v &= ~__mask; } __attribute__((__nonnull__)) inline void __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept { # 1802 "/usr/include/c++/15/bits/stl_bvector.h" 3 __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type)); } inline void __fill_a1(std::_Bit_iterator __first, std::_Bit_iterator __last, const bool& __x) { if (__first._M_p != __last._M_p) { _Bit_type* __first_p = __first._M_p; if (__first._M_offset != 0) __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x); __fill_bvector_n(__first_p, __last._M_p - __first_p, __x); if (__last._M_offset != 0) __fill_bvector(__last._M_p, 0, __last._M_offset, __x); } else if (__first._M_offset != __last._M_offset) __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x); } template struct hash> : public __hash_base> { size_t operator()(const std::vector&) const noexcept; }; } # 70 "/usr/include/c++/15/vector" 2 3 # 1 "/usr/include/c++/15/bits/vector.tcc" 1 3 # 59 "/usr/include/c++/15/bits/vector.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void vector<_Tp, _Alloc>:: reserve(size_type __n) { if (__n > this->max_size()) __throw_length_error(("vector::reserve")); if (this->capacity() < __n) { const size_type __old_size = size(); pointer __tmp; if constexpr (_S_use_relocate()) { __tmp = this->_M_allocate(__n); _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, __tmp, _M_get_Tp_allocator()); } else { __tmp = _M_allocate_and_copy(__n, std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); } ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __tmp; this->_M_impl._M_finish = __tmp + __old_size; this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; } } template template typename vector<_Tp, _Alloc>::reference vector<_Tp, _Alloc>:: emplace_back(_Args&&... __args) { if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::forward<_Args>(__args)...); ++this->_M_impl._M_finish; ; } else _M_realloc_append(std::forward<_Args>(__args)...); return back(); } template typename vector<_Tp, _Alloc>::iterator vector<_Tp, _Alloc>:: insert(const_iterator __position, const value_type& __x) { const size_type __n = __position - begin(); if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) { do { if (std::__is_constant_evaluated() && !bool(__position != const_iterator())) std::__glibcxx_assert_fail(); } while (false); if (!(__position != const_iterator())) __builtin_unreachable(); if (__position == end()) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x); ++this->_M_impl._M_finish; ; } else { const auto __pos = begin() + (__position - cbegin()); _Temporary_value __x_copy(this, __x); _M_insert_aux(__pos, std::move(__x_copy._M_val())); } } else _M_realloc_insert(begin() + (__position - cbegin()), __x); return iterator(this->_M_impl._M_start + __n); } template typename vector<_Tp, _Alloc>::iterator vector<_Tp, _Alloc>:: _M_erase(iterator __position) { if (__position + 1 != end()) std::move(__position + 1, end(), __position); --this->_M_impl._M_finish; _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); ; return __position; } template typename vector<_Tp, _Alloc>::iterator vector<_Tp, _Alloc>:: _M_erase(iterator __first, iterator __last) { if (__first != __last) { if (__last != end()) std::move(__last, end(), __first); _M_erase_at_end(__first.base() + (end() - __last)); } return __first; } template vector<_Tp, _Alloc>& vector<_Tp, _Alloc>:: operator=(const vector<_Tp, _Alloc>& __x) { if (std::__addressof(__x) != this) { ; if (_Alloc_traits::_S_propagate_on_copy_assign()) { if (!_Alloc_traits::_S_always_equal() && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) { this->clear(); _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = nullptr; this->_M_impl._M_finish = nullptr; this->_M_impl._M_end_of_storage = nullptr; } std::__alloc_on_copy(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } const size_type __xlen = __x.size(); if (__xlen > capacity()) { pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end()); std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __tmp; this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; } else if (size() >= __xlen) { std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), end(), _M_get_Tp_allocator()); } else { std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), this->_M_impl._M_start); std::__uninitialized_copy_a(__x._M_impl._M_start + size(), __x._M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); } this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; } return *this; } template void vector<_Tp, _Alloc>:: _M_fill_assign(size_t __n, const value_type& __val) { const size_type __sz = size(); if (__n > capacity()) { if (__n <= __sz) __builtin_unreachable(); vector __tmp(__n, __val, _M_get_Tp_allocator()); __tmp._M_impl._M_swap_data(this->_M_impl); } else if (__n > __sz) { std::fill(begin(), end(), __val); const size_type __add = __n - __sz; ; this->_M_impl._M_finish = std::__uninitialized_fill_n_a(this->_M_impl._M_finish, __add, __val, _M_get_Tp_allocator()); ; } else _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); } template template void vector<_Tp, _Alloc>:: _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { pointer __cur(this->_M_impl._M_start); for (; __first != __last && __cur != this->_M_impl._M_finish; ++__cur, (void)++__first) *__cur = *__first; if (__first == __last) _M_erase_at_end(__cur); else _M_range_insert(end(), __first, __last, std::__iterator_category(__first)); } template template void vector<_Tp, _Alloc>:: _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __sz = size(); const size_type __len = std::distance(__first, __last); if (__len > capacity()) { if (__len <= __sz) __builtin_unreachable(); _S_check_init_len(__len, _M_get_Tp_allocator()); pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __tmp; this->_M_impl._M_finish = this->_M_impl._M_start + __len; this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; } else if (__sz >= __len) _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); else { _ForwardIterator __mid = __first; std::advance(__mid, __sz); std::copy(__first, __mid, this->_M_impl._M_start); const size_type __attribute__((__unused__)) __n = __len - __sz; ; this->_M_impl._M_finish = std::__uninitialized_copy_a(__mid, __last, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; } } template auto vector<_Tp, _Alloc>:: _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator { const auto __n = __position - cbegin(); if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) if (__position == cend()) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::move(__v)); ++this->_M_impl._M_finish; ; } else _M_insert_aux(begin() + __n, std::move(__v)); else _M_realloc_insert(begin() + __n, std::move(__v)); return iterator(this->_M_impl._M_start + __n); } template template auto vector<_Tp, _Alloc>:: _M_emplace_aux(const_iterator __position, _Args&&... __args) -> iterator { const auto __n = __position - cbegin(); if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) if (__position == cend()) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::forward<_Args>(__args)...); ++this->_M_impl._M_finish; ; } else { _Temporary_value __tmp(this, std::forward<_Args>(__args)...); _M_insert_aux(begin() + __n, std::move(__tmp._M_val())); } else _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...); return iterator(this->_M_impl._M_start + __n); } template template void vector<_Tp, _Alloc>:: _M_insert_aux(iterator __position, _Arg&& __arg) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::move(*(this->_M_impl._M_finish - 1))); ++this->_M_impl._M_finish; ; std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1) ; *__position = std::forward<_Arg>(__arg); } template template void vector<_Tp, _Alloc>:: _M_realloc_insert(iterator __position, _Args&&... __args) { const size_type __len = _M_check_len(1u, "vector::_M_realloc_insert"); if (__len <= 0) __builtin_unreachable (); pointer __old_start = this->_M_impl._M_start; pointer __old_finish = this->_M_impl._M_finish; const size_type __elems_before = __position - begin(); pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); { _Guard_alloc __guard(__new_start, __len, *this); # 481 "/usr/include/c++/15/bits/vector.tcc" 3 _Alloc_traits::construct(this->_M_impl, std::__to_address(__new_start + __elems_before), std::forward<_Args>(__args)...); if constexpr (_S_use_relocate()) { __new_finish = _S_relocate(__old_start, __position.base(), __new_start, _M_get_Tp_allocator()); ++__new_finish; __new_finish = _S_relocate(__position.base(), __old_finish, __new_finish, _M_get_Tp_allocator()); } else { struct _Guard_elts { pointer _M_first, _M_last; _Tp_alloc_type& _M_alloc; _Guard_elts(pointer __elt, _Tp_alloc_type& __a) : _M_first(__elt), _M_last(__elt + 1), _M_alloc(__a) { } ~_Guard_elts() { std::_Destroy(_M_first, _M_last, _M_alloc); } private: _Guard_elts(const _Guard_elts&); }; _Guard_elts __guard_elts(__new_start + __elems_before, _M_impl); __new_finish = std::__uninitialized_move_if_noexcept_a( __old_start, __position.base(), __new_start, _M_get_Tp_allocator()); ++__new_finish; __guard_elts._M_first = __new_start; __new_finish = std::__uninitialized_move_if_noexcept_a( __position.base(), __old_finish, __new_finish, _M_get_Tp_allocator()); __guard_elts._M_first = __old_start; __guard_elts._M_last = __old_finish; } __guard._M_storage = __old_start; __guard._M_len = this->_M_impl._M_end_of_storage - __old_start; } this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } template template void vector<_Tp, _Alloc>:: _M_realloc_append(_Args&&... __args) { const size_type __len = _M_check_len(1u, "vector::_M_realloc_append"); if (__len <= 0) __builtin_unreachable (); pointer __old_start = this->_M_impl._M_start; pointer __old_finish = this->_M_impl._M_finish; const size_type __elems = end() - begin(); pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); { _Guard_alloc __guard(__new_start, __len, *this); # 586 "/usr/include/c++/15/bits/vector.tcc" 3 _Alloc_traits::construct(this->_M_impl, std::__to_address(__new_start + __elems), std::forward<_Args>(__args)...); if constexpr (_S_use_relocate()) { __new_finish = _S_relocate(__old_start, __old_finish, __new_start, _M_get_Tp_allocator()); ++__new_finish; } else { struct _Guard_elts { pointer _M_first, _M_last; _Tp_alloc_type& _M_alloc; _Guard_elts(pointer __elt, _Tp_alloc_type& __a) : _M_first(__elt), _M_last(__elt + 1), _M_alloc(__a) { } ~_Guard_elts() { std::_Destroy(_M_first, _M_last, _M_alloc); } private: _Guard_elts(const _Guard_elts&); }; _Guard_elts __guard_elts(__new_start + __elems, _M_impl); __new_finish = std::__uninitialized_move_if_noexcept_a( __old_start, __old_finish, __new_start, _M_get_Tp_allocator()); ++__new_finish; __guard_elts._M_first = __old_start; __guard_elts._M_last = __old_finish; } __guard._M_storage = __old_start; __guard._M_len = this->_M_impl._M_end_of_storage - __old_start; } this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } template void vector<_Tp, _Alloc>:: _M_fill_insert(iterator __position, size_type __n, const value_type& __x) { if (__n != 0) { if (size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_finish) >= __n) { _Temporary_value __tmp(this, __x); value_type& __x_copy = __tmp._M_val(); const size_type __elems_after = end() - __position; pointer __old_finish(this->_M_impl._M_finish); if (__elems_after > __n) { ; std::__uninitialized_move_a(__old_finish - __n, __old_finish, __old_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __n; ; std::move_backward(__position.base(), __old_finish - __n, __old_finish) ; std::fill(__position.base(), __position.base() + __n, __x_copy); } else { ; this->_M_impl._M_finish = std::__uninitialized_fill_n_a(__old_finish, __n - __elems_after, __x_copy, _M_get_Tp_allocator()); ; std::__uninitialized_move_a(__position.base(), __old_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __elems_after; ; std::fill(__position.base(), __old_finish, __x_copy); } } else { pointer __old_start = this->_M_impl._M_start; pointer __old_finish = this->_M_impl._M_finish; const pointer __pos = __position.base(); const size_type __len = _M_check_len(__n, "vector::_M_fill_insert"); const size_type __elems_before = __pos - __old_start; pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); try { std::__uninitialized_fill_n_a(__new_start + __elems_before, __n, __x, _M_get_Tp_allocator()); __new_finish = pointer(); __new_finish = std::__uninitialized_move_if_noexcept_a (__old_start, __pos, __new_start, _M_get_Tp_allocator()); __new_finish += __n; __new_finish = std::__uninitialized_move_if_noexcept_a (__pos, __old_finish, __new_finish, _M_get_Tp_allocator()); } catch(...) { if (!__new_finish) std::_Destroy(__new_start + __elems_before, __new_start + __elems_before + __n, _M_get_Tp_allocator()); else std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); _M_deallocate(__new_start, __len); throw; } std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); ; _M_deallocate(__old_start, this->_M_impl._M_end_of_storage - __old_start); this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } } } template void vector<_Tp, _Alloc>:: _M_default_append(size_type __n) { if (__n != 0) { const size_type __size = size(); size_type __navail = size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_finish); if (__size > max_size() || __navail > max_size() - __size) __builtin_unreachable(); if (__navail >= __n) { if (!this->_M_impl._M_finish) __builtin_unreachable(); ; this->_M_impl._M_finish = std::__uninitialized_default_n_a(this->_M_impl._M_finish, __n, _M_get_Tp_allocator()); ; } else { pointer __old_start = this->_M_impl._M_start; pointer __old_finish = this->_M_impl._M_finish; const size_type __len = _M_check_len(__n, "vector::_M_default_append"); pointer __new_start(this->_M_allocate(__len)); { _Guard_alloc __guard(__new_start, __len, *this); std::__uninitialized_default_n_a(__new_start + __size, __n, _M_get_Tp_allocator()); if constexpr (_S_use_relocate()) { _S_relocate(__old_start, __old_finish, __new_start, _M_get_Tp_allocator()); } else { struct _Guard_elts { pointer _M_first, _M_last; _Tp_alloc_type& _M_alloc; _Guard_elts(pointer __first, size_type __n, _Tp_alloc_type& __a) : _M_first(__first), _M_last(__first + __n), _M_alloc(__a) { } ~_Guard_elts() { std::_Destroy(_M_first, _M_last, _M_alloc); } private: _Guard_elts(const _Guard_elts&); }; _Guard_elts __guard_elts(__new_start + __size, __n, _M_impl); std::__uninitialized_move_if_noexcept_a( __old_start, __old_finish, __new_start, _M_get_Tp_allocator()); __guard_elts._M_first = __old_start; __guard_elts._M_last = __old_finish; } ; __guard._M_storage = __old_start; __guard._M_len = this->_M_impl._M_end_of_storage - __old_start; } this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_start + __size + __n; this->_M_impl._M_end_of_storage = __new_start + __len; } } } template bool vector<_Tp, _Alloc>:: _M_shrink_to_fit() { if (capacity() == size()) return false; ; return std::__shrink_to_fit_aux::_S_do_it(*this); } template template void vector<_Tp, _Alloc>:: _M_range_insert(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag) { if (__pos == end()) { for (; __first != __last; ++__first) insert(end(), *__first); } else if (__first != __last) { vector __tmp(__first, __last, _M_get_Tp_allocator()); insert(__pos, std::make_move_iterator(__tmp.begin()), std::make_move_iterator(__tmp.end())); } } template template void vector<_Tp, _Alloc>:: _M_range_insert(iterator __position, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { if (__first != __last) { const size_type __n = std::distance(__first, __last); if (size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_finish) >= __n) { const size_type __elems_after = end() - __position; pointer __old_finish(this->_M_impl._M_finish); if (__elems_after > __n) { ; std::__uninitialized_move_a(this->_M_impl._M_finish - __n, this->_M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __n; ; std::move_backward(__position.base(), __old_finish - __n, __old_finish) ; std::copy(__first, __last, __position); } else { _ForwardIterator __mid = __first; std::advance(__mid, __elems_after); ; std::__uninitialized_copy_a(__mid, __last, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __n - __elems_after; ; std::__uninitialized_move_a(__position.base(), __old_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __elems_after; ; std::copy(__first, __mid, __position); } } else { pointer __old_start = this->_M_impl._M_start; pointer __old_finish = this->_M_impl._M_finish; const size_type __len = _M_check_len(__n, "vector::_M_range_insert"); pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); try { __new_finish = std::__uninitialized_move_if_noexcept_a (__old_start, __position.base(), __new_start, _M_get_Tp_allocator()); __new_finish = std::__uninitialized_copy_a(__first, __last, __new_finish, _M_get_Tp_allocator()); __new_finish = std::__uninitialized_move_if_noexcept_a (__position.base(), __old_finish, __new_finish, _M_get_Tp_allocator()); } catch(...) { std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); _M_deallocate(__new_start, __len); throw; } std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); ; _M_deallocate(__old_start, this->_M_impl._M_end_of_storage - __old_start); this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } } } # 1109 "/usr/include/c++/15/bits/vector.tcc" 3 template void vector:: _M_reallocate(size_type __n) { const iterator __begin = begin(), __end = end(); if (size_type(__end - __begin) > __n) __builtin_unreachable(); _Bit_pointer __q = this->_M_allocate(__n); iterator __start(std::__addressof(*__q), 0); iterator __finish(_M_copy_aligned(__begin, __end, __start)); this->_M_deallocate(); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; this->_M_impl._M_end_of_storage = __q + _S_nword(__n); } template void vector:: _M_fill_insert(iterator __position, size_type __n, bool __x) { if (__n == 0) return; if (capacity() - size() >= __n) { std::copy_backward(__position, end(), this->_M_impl._M_finish + difference_type(__n)); std::fill(__position, __position + difference_type(__n), __x); this->_M_impl._M_finish += difference_type(__n); } else { const size_type __len = _M_check_len(__n, "vector::_M_fill_insert"); iterator __begin = begin(), __end = end(); _Bit_pointer __q = this->_M_allocate(__len); iterator __start(std::__addressof(*__q), 0); iterator __i = _M_copy_aligned(__begin, __position, __start); std::fill(__i, __i + difference_type(__n), __x); iterator __finish = std::copy(__position, __end, __i + difference_type(__n)); this->_M_deallocate(); this->_M_impl._M_end_of_storage = __q + _S_nword(__len); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; } } template template void vector:: _M_insert_range(iterator __position, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { if (__first != __last) { size_type __n = std::distance(__first, __last); if (capacity() - size() >= __n) { std::copy_backward(__position, end(), this->_M_impl._M_finish + difference_type(__n)); std::copy(__first, __last, __position); this->_M_impl._M_finish += difference_type(__n); } else { const size_type __len = _M_check_len(__n, "vector::_M_insert_range"); const iterator __begin = begin(), __end = end(); _Bit_pointer __q = this->_M_allocate(__len); iterator __start(std::__addressof(*__q), 0); iterator __i = _M_copy_aligned(__begin, __position, __start); __i = std::copy(__first, __last, __i); iterator __finish = std::copy(__position, __end, __i); this->_M_deallocate(); this->_M_impl._M_end_of_storage = __q + _S_nword(__len); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; } } } template void vector:: _M_insert_aux(iterator __position, bool __x) { if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) { std::copy_backward(__position, this->_M_impl._M_finish, this->_M_impl._M_finish + 1); *__position = __x; ++this->_M_impl._M_finish; } else { const size_type __len = _M_check_len(size_type(1), "vector::_M_insert_aux"); _Bit_pointer __q = this->_M_allocate(__len); iterator __start(std::__addressof(*__q), 0); iterator __i = _M_copy_aligned(begin(), __position, __start); *__i++ = __x; iterator __finish = std::copy(__position, end(), __i); this->_M_deallocate(); this->_M_impl._M_end_of_storage = __q + _S_nword(__len); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; } } template typename vector::iterator vector:: _M_erase(iterator __position) { if (__position + 1 != end()) std::copy(__position + 1, end(), __position); --this->_M_impl._M_finish; return __position; } template typename vector::iterator vector:: _M_erase(iterator __first, iterator __last) { if (__first != __last) _M_erase_at_end(std::copy(__last, end(), __first)); return __first; } template bool vector:: _M_shrink_to_fit() { if (capacity() - size() < int(_S_word_bit)) return false; try { if (size_type __n = size()) _M_reallocate(__n); else { this->_M_deallocate(); this->_M_impl._M_reset(); } return true; } catch(...) { return false; } } } namespace std __attribute__ ((__visibility__ ("default"))) { template size_t hash>:: operator()(const std::vector& __b) const noexcept { size_t __hash = 0; const size_t __words = __b.size() / _S_word_bit; if (__words) { const size_t __clength = __words * sizeof(_Bit_type); __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); } const size_t __extrabits = __b.size() % _S_word_bit; if (__extrabits) { _Bit_type __hiword = *__b._M_impl._M_finish._M_p; __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); const size_t __clength = (__extrabits + 8 - 1) / 8; if (__words) __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); else __hash = std::_Hash_impl::hash(&__hiword, __clength); } return __hash; } } # 75 "/usr/include/c++/15/vector" 2 3 # 88 "/usr/include/c++/15/vector" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 89 "/usr/include/c++/15/vector" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>; } } # 67 "/usr/include/c++/15/functional" 2 3 # 1 "/usr/include/c++/15/array" 1 3 # 40 "/usr/include/c++/15/array" 3 # 1 "/usr/include/c++/15/compare" 1 3 # 38 "/usr/include/c++/15/compare" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 39 "/usr/include/c++/15/compare" 2 3 # 41 "/usr/include/c++/15/array" 2 3 # 54 "/usr/include/c++/15/array" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 55 "/usr/include/c++/15/array" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct __array_traits { using _Type = _Tp[_Nm]; using _Is_swappable = __is_swappable<_Tp>; using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>; }; template struct __array_traits<_Tp, 0> { struct _Type { __attribute__((__always_inline__,__noreturn__)) _Tp& operator[](size_t) const noexcept { __builtin_trap(); } __attribute__((__always_inline__)) constexpr explicit operator _Tp*() const noexcept { return nullptr; } }; using _Is_swappable = true_type; using _Is_nothrow_swappable = true_type; }; # 101 "/usr/include/c++/15/array" 3 template struct array { typedef _Tp value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* iterator; typedef const value_type* const_iterator; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; typename __array_traits<_Tp, _Nm>::_Type _M_elems; void fill(const value_type& __u) { std::fill_n(begin(), size(), __u); } void swap(array& __other) noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value) { std::swap_ranges(begin(), end(), __other.begin()); } [[__gnu__::__const__, __nodiscard__]] constexpr iterator begin() noexcept { return iterator(data()); } [[__nodiscard__]] constexpr const_iterator begin() const noexcept { return const_iterator(data()); } [[__gnu__::__const__, __nodiscard__]] constexpr iterator end() noexcept { return iterator(data() + _Nm); } [[__nodiscard__]] constexpr const_iterator end() const noexcept { return const_iterator(data() + _Nm); } [[__gnu__::__const__, __nodiscard__]] constexpr reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } [[__nodiscard__]] constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } [[__gnu__::__const__, __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 const_iterator(data()); } [[__nodiscard__]] constexpr const_iterator cend() const noexcept { return const_iterator(data() + _Nm); } [[__nodiscard__]] constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } [[__nodiscard__]] constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] constexpr size_type size() const noexcept { return _Nm; } [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] constexpr size_type max_size() const noexcept { return _Nm; } [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] constexpr bool empty() const noexcept { return size() == 0; } [[__nodiscard__]] constexpr reference operator[](size_type __n) noexcept { do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false); return _M_elems[__n]; } [[__nodiscard__]] constexpr const_reference operator[](size_type __n) const noexcept { do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false); return _M_elems[__n]; } constexpr reference at(size_type __n) { if (__n >= _Nm) std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)") , __n, _Nm); return _M_elems[__n]; } constexpr const_reference at(size_type __n) const { return __n < _Nm ? _M_elems[__n] : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)") , __n, _Nm), _M_elems[__n]); } [[__nodiscard__]] constexpr reference front() noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return _M_elems[(size_type)0]; } [[__nodiscard__]] constexpr const_reference front() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return _M_elems[(size_type)0]; } [[__nodiscard__]] constexpr reference back() noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return _M_elems[_Nm - 1]; } [[__nodiscard__]] constexpr const_reference back() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false); return _M_elems[_Nm - 1]; } [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] constexpr pointer data() noexcept { return static_cast(_M_elems); } [[__nodiscard__]] constexpr const_pointer data() const noexcept { return static_cast(_M_elems); } }; template array(_Tp, _Up...) -> array && ...), _Tp>, 1 + sizeof...(_Up)>; template [[__nodiscard__]] inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::__equal_aux1(__one.begin(), __one.end(), __two.begin()); } # 330 "/usr/include/c++/15/array" 3 template [[__nodiscard__]] inline bool operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one == __two); } template [[__nodiscard__]] inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) { return std::lexicographical_compare(__a.begin(), __a.end(), __b.begin(), __b.end()); } template [[__nodiscard__]] inline bool operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return __two < __one; } template [[__nodiscard__]] inline bool operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one > __two); } template [[__nodiscard__]] inline bool operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one < __two); } template inline __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value> swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(noexcept(__one.swap(__two))) { __one.swap(__two); } template __enable_if_t::_Is_swappable::value> swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; template [[__nodiscard__]] constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return __arr._M_elems[_Int]; } template [[__nodiscard__]] constexpr _Tp&& get(array<_Tp, _Nm>&& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return std::move(std::get<_Int>(__arr)); } template [[__nodiscard__]] constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return __arr._M_elems[_Int]; } template [[__nodiscard__]] constexpr const _Tp&& get(const array<_Tp, _Nm>&& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return std::move(std::get<_Int>(__arr)); } # 492 "/usr/include/c++/15/array" 3 template struct tuple_size> : public integral_constant { }; template struct tuple_element<_Ind, array<_Tp, _Nm>> { static_assert(_Ind < _Nm, "array index is in range"); using type = _Tp; }; template inline constexpr size_t tuple_size_v> = _Nm; template inline constexpr size_t tuple_size_v> = _Nm; template struct __is_tuple_like_impl> : true_type { }; } # 68 "/usr/include/c++/15/functional" 2 3 # 90 "/usr/include/c++/15/functional" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 91 "/usr/include/c++/15/functional" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _Placeholder { }; # 117 "/usr/include/c++/15/functional" 3 template inline invoke_result_t<_Callable, _Args...> invoke(_Callable&& __fn, _Args&&... __args) noexcept(is_nothrow_invocable_v<_Callable, _Args...>) { return std::__invoke(std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); } # 150 "/usr/include/c++/15/functional" 3 template::value> class _Mem_fn_base : public _Mem_fn_traits<_MemFunPtr>::__maybe_type { using _Traits = _Mem_fn_traits<_MemFunPtr>; using _Arity = typename _Traits::__arity; using _Varargs = typename _Traits::__vararg; template friend struct _Bind_check_arity; _MemFunPtr _M_pmf; public: using result_type = typename _Traits::__result_type; explicit constexpr _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { } template auto operator()(_Args&&... __args) const noexcept(noexcept( std::__invoke(_M_pmf, std::forward<_Args>(__args)...))) -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...)) { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); } }; template class _Mem_fn_base<_MemObjPtr, false> { using _Arity = integral_constant; using _Varargs = false_type; template friend struct _Bind_check_arity; _MemObjPtr _M_pm; public: explicit constexpr _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { } template auto operator()(_Tp&& __obj) const noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))) -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj))) { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); } }; template struct _Mem_fn; template struct _Mem_fn<_Res _Class::*> : _Mem_fn_base<_Res _Class::*> { using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base; }; # 243 "/usr/include/c++/15/functional" 3 template inline _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::* __pm) noexcept { return _Mem_fn<_Tp _Class::*>(__pm); } # 262 "/usr/include/c++/15/functional" 3 template struct is_bind_expression : public false_type { }; # 274 "/usr/include/c++/15/functional" 3 template struct is_placeholder : public integral_constant { }; template inline constexpr bool is_bind_expression_v = is_bind_expression<_Tp>::value; template inline constexpr int is_placeholder_v = is_placeholder<_Tp>::value; namespace placeholders { # 303 "/usr/include/c++/15/functional" 3 inline const _Placeholder<1> _1; inline const _Placeholder<2> _2; inline const _Placeholder<3> _3; inline const _Placeholder<4> _4; inline const _Placeholder<5> _5; inline const _Placeholder<6> _6; inline const _Placeholder<7> _7; inline const _Placeholder<8> _8; inline const _Placeholder<9> _9; inline const _Placeholder<10> _10; inline const _Placeholder<11> _11; inline const _Placeholder<12> _12; inline const _Placeholder<13> _13; inline const _Placeholder<14> _14; inline const _Placeholder<15> _15; inline const _Placeholder<16> _16; inline const _Placeholder<17> _17; inline const _Placeholder<18> _18; inline const _Placeholder<19> _19; inline const _Placeholder<20> _20; inline const _Placeholder<21> _21; inline const _Placeholder<22> _22; inline const _Placeholder<23> _23; inline const _Placeholder<24> _24; inline const _Placeholder<25> _25; inline const _Placeholder<26> _26; inline const _Placeholder<27> _27; inline const _Placeholder<28> _28; inline const _Placeholder<29> _29; } template struct is_placeholder<_Placeholder<_Num> > : public integral_constant { }; template struct is_placeholder > : public integral_constant { }; template using _Safe_tuple_element_t = typename enable_if<(__i < tuple_size<_Tuple>::value), tuple_element<__i, _Tuple>>::type::type; # 371 "/usr/include/c++/15/functional" 3 template::value, bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> class _Mu; template class _Mu, false, false> { public: template _Tp& operator()(_CVRef& __arg, _Tuple&) const volatile { return __arg.get(); } }; template class _Mu<_Arg, true, false> { public: template auto operator()(_CVArg& __arg, tuple<_Args...>& __tuple) const volatile -> decltype(__arg(declval<_Args>()...)) { typedef typename _Build_index_tuple::__type _Indexes; return this->__call(__arg, __tuple, _Indexes()); } private: template auto __call(_CVArg& __arg, tuple<_Args...>& __tuple, const _Index_tuple<_Indexes...>&) const volatile -> decltype(__arg(declval<_Args>()...)) { return __arg(std::get<_Indexes>(std::move(__tuple))...); } }; template class _Mu<_Arg, false, true> { public: template _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&& operator()(const volatile _Arg&, _Tuple& __tuple) const volatile { return ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple)); } }; template class _Mu<_Arg, false, false> { public: template _CVArg&& operator()(_CVArg&& __arg, _Tuple&) const volatile { return std::forward<_CVArg>(__arg); } }; template inline auto __volget(volatile tuple<_Tp...>& __tuple) -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile& { return std::get<_Ind>(const_cast&>(__tuple)); } template inline auto __volget(const volatile tuple<_Tp...>& __tuple) -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile& { return std::get<_Ind>(const_cast&>(__tuple)); } # 496 "/usr/include/c++/15/functional" 3 template class _Bind; template class _Bind<_Functor(_Bound_args...)> : public _Weak_result_type<_Functor> { typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; template _Result __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { return std::__invoke(_M_f, _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)... ); } template _Result __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { return std::__invoke(_M_f, _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)... ); } template _Result __call_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { return std::__invoke(_M_f, _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)... ); } template _Result __call_c_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { return std::__invoke(_M_f, _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)... ); } template using _Mu_type = decltype( _Mu::type>()( std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) ); template using _Res_type_impl = __invoke_result_t<_Fn&, _Mu_type<_BArgs, _CallArgs>&&...>; template using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>; template using __dependent = typename enable_if::value+1), _Functor>::type; template class __cv_quals> using _Res_type_cv = _Res_type_impl< typename __cv_quals<__dependent<_CallArgs>>::type, _CallArgs, typename __cv_quals<_Bound_args>::type...>; public: template explicit _Bind(const _Functor& __f, _Args&&... __args) : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) { } template explicit _Bind(_Functor&& __f, _Args&&... __args) : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) { } _Bind(const _Bind&) = default; _Bind(_Bind&&) = default; template>> _Result operator()(_Args&&... __args) { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template, add_const>> _Result operator()(_Args&&... __args) const { return this->__call_c<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template, add_volatile>> [[deprecated("std::bind does not support volatile in C++17")]] _Result operator()(_Args&&... __args) volatile { return this->__call_v<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template, add_cv>> [[deprecated("std::bind does not support volatile in C++17")]] _Result operator()(_Args&&... __args) const volatile { return this->__call_c_v<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } }; template class _Bind_result; template class _Bind_result<_Result, _Functor(_Bound_args...)> { typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; template _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } template _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } template _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } template _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } public: typedef _Result result_type; template explicit _Bind_result(const _Functor& __f, _Args&&... __args) : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) { } template explicit _Bind_result(_Functor&& __f, _Args&&... __args) : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) { } _Bind_result(const _Bind_result&) = default; _Bind_result(_Bind_result&&) = default; template result_type operator()(_Args&&... __args) { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template result_type operator()(_Args&&... __args) const { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template [[deprecated("std::bind does not support volatile in C++17")]] result_type operator()(_Args&&... __args) volatile { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template [[deprecated("std::bind does not support volatile in C++17")]] result_type operator()(_Args&&... __args) const volatile { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } }; # 773 "/usr/include/c++/15/functional" 3 template struct is_bind_expression<_Bind<_Signature> > : public true_type { }; template struct is_bind_expression > : public true_type { }; template struct is_bind_expression > : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct is_bind_expression<_Bind_result<_Result, _Signature>> : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct _Bind_check_arity { }; template struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...> { static_assert(sizeof...(_BoundArgs) == sizeof...(_Args), "Wrong number of arguments for function"); }; template struct _Bind_check_arity<_Ret (*)(_Args..., ...), _BoundArgs...> { static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args), "Wrong number of arguments for function"); }; template struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...> { using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity; using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs; static_assert(_Varargs::value ? sizeof...(_BoundArgs) >= _Arity::value + 1 : sizeof...(_BoundArgs) == _Arity::value + 1, "Wrong number of arguments for pointer-to-member"); }; template::type> using __is_socketlike = __or_, is_enum<_Tp2>>; template struct _Bind_helper : _Bind_check_arity::type, _BoundArgs...> { typedef typename decay<_Func>::type __func_type; typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type; }; template struct _Bind_helper { }; template inline typename _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type bind(_Func&& __f, _BoundArgs&&... __args) { typedef _Bind_helper __helper_type; return typename __helper_type::type(std::forward<_Func>(__f), std::forward<_BoundArgs>(__args)...); } template struct _Bindres_helper : _Bind_check_arity::type, _BoundArgs...> { typedef typename decay<_Func>::type __functor_type; typedef _Bind_result<_Result, __functor_type(typename decay<_BoundArgs>::type...)> type; }; template inline typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type bind(_Func&& __f, _BoundArgs&&... __args) { typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type; return typename __helper_type::type(std::forward<_Func>(__f), std::forward<_BoundArgs>(__args)...); } # 1123 "/usr/include/c++/15/functional" 3 template class _Not_fn { template using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type; template static decltype(!std::declval<_Tp>()) _S_not() noexcept(noexcept(!std::declval<_Tp>())); public: template constexpr _Not_fn(_Fn2&& __fn, int) : _M_fn(std::forward<_Fn2>(__fn)) { } _Not_fn(const _Not_fn& __fn) = default; _Not_fn(_Not_fn&& __fn) = default; ~_Not_fn() = default; # 1163 "/usr/include/c++/15/functional" 3 template::value>> decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); } template::value>> void operator()(_Args&&... __args) & = delete; template::value>> decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); } template::value>> void operator()(_Args&&... __args) const & = delete; template::value>> decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); } template::value>> void operator()(_Args&&... __args) && = delete; template::value>> decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); } template::value>> void operator()(_Args&&... __args) const && = delete; private: _Fn _M_fn; }; template struct __is_byte_like : false_type { }; template struct __is_byte_like<_Tp, equal_to<_Tp>> : __bool_constant::value> { }; template struct __is_byte_like<_Tp, equal_to> : __bool_constant::value> { }; enum class byte : unsigned char; template<> struct __is_byte_like> : true_type { }; template<> struct __is_byte_like> : true_type { }; # 1211 "/usr/include/c++/15/functional" 3 template inline auto not_fn(_Fn&& __fn) noexcept(std::is_nothrow_constructible, _Fn&&>::value) { return _Not_fn>{std::forward<_Fn>(__fn), 0}; } template> class default_searcher { public: default_searcher(_ForwardIterator1 __pat_first, _ForwardIterator1 __pat_last, _BinaryPredicate __pred = _BinaryPredicate()) : _M_m(__pat_first, __pat_last, std::move(__pred)) { } template pair<_ForwardIterator2, _ForwardIterator2> operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const { _ForwardIterator2 __first_ret = std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m), std::get<2>(_M_m)); auto __ret = std::make_pair(__first_ret, __first_ret); if (__ret.first != __last) std::advance(__ret.second, std::distance(std::get<0>(_M_m), std::get<1>(_M_m))); return __ret; } private: tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m; }; template struct __boyer_moore_map_base { template __boyer_moore_map_base(_RAIter __pat, size_t __patlen, _Hash&& __hf, _Pred&& __pred) : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) } { if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) _M_bad_char[__pat[__i]] = __patlen - 1 - __i; } using __diff_type = _Tp; __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __iter = _M_bad_char.find(__key); if (__iter == _M_bad_char.end()) return __not_found; return __iter->second; } _Pred _M_pred() const { return _M_bad_char.key_eq(); } std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char; }; template struct __boyer_moore_array_base { template __boyer_moore_array_base(_RAIter __pat, size_t __patlen, _Unused&&, _Pred&& __pred) : _M_bad_char{ array<_Tp, _Len>{}, std::move(__pred) } { std::get<0>(_M_bad_char).fill(__patlen); if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) { auto __ch = __pat[__i]; using _UCh = make_unsigned_t; auto __uch = static_cast<_UCh>(__ch); std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i; } } using __diff_type = _Tp; template __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __ukey = static_cast>(__key); if (__ukey >= _Len) return __not_found; return std::get<0>(_M_bad_char)[__ukey]; } const _Pred& _M_pred() const { return std::get<1>(_M_bad_char); } tuple, _Pred> _M_bad_char; }; template::value_type, typename _Diff = typename iterator_traits<_RAIter>::difference_type> using __boyer_moore_base_t = __conditional_t<__is_byte_like<_Val, _Pred>::value, __boyer_moore_array_base<_Diff, 256, _Pred>, __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>; template::value_type>, typename _BinaryPredicate = equal_to<>> class boyer_moore_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()); template pair<_RandomAccessIterator2, _RandomAccessIterator2> operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const; private: bool _M_is_prefix(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __suffixlen = __len - __pos; for (__diff_type __i = 0; __i < __suffixlen; ++__i) if (!__pred(__word[__i], __word[__pos + __i])) return false; return true; } __diff_type _M_suffix_length(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __i = 0; while (__pred(__word[__pos - __i], __word[__len - 1 - __i]) && __i < __pos) { ++__i; } return __i; } template __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; std::vector<__diff_type> _M_good_suffix; }; template::value_type>, typename _BinaryPredicate = equal_to<>> class boyer_moore_horspool_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_horspool_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end) { } template pair<_RandomAccessIterator2, _RandomAccessIterator2> operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { const auto& __pred = this->_M_pred(); auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return std::make_pair(__first, __first); auto __len = __last - __first; while (__len >= __patlen) { for (auto __scan = __patlen - 1; __pred(__first[__scan], _M_pat[__scan]); --__scan) if (__scan == 0) return std::make_pair(__first, __first + __patlen); auto __shift = _M_bad_char_shift(__first[__patlen - 1]); __len -= __shift; __first += __shift; } return std::make_pair(__last, __last); } private: template __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; }; template boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf, _BinaryPredicate __pred) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat) { auto __patlen = __pat_end - __pat; if (__patlen == 0) return; __diff_type __last_prefix = __patlen - 1; for (__diff_type __p = __patlen - 1; __p >= 0; --__p) { if (_M_is_prefix(__pat, __patlen, __p + 1)) __last_prefix = __p + 1; _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p); } for (__diff_type __p = 0; __p < __patlen - 1; ++__p) { auto __slen = _M_suffix_length(__pat, __patlen, __p); auto __pos = __patlen - 1 - __slen; if (!__pred(__pat[__p - __slen], __pat[__pos])) _M_good_suffix[__pos] = __patlen - 1 - __p + __slen; } } template template pair<_RandomAccessIterator2, _RandomAccessIterator2> boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return std::make_pair(__first, __first); const auto& __pred = this->_M_pred(); __diff_type __i = __patlen - 1; auto __stringlen = __last - __first; while (__i < __stringlen) { __diff_type __j = __patlen - 1; while (__j >= 0 && __pred(__first[__i], _M_pat[__j])) { --__i; --__j; } if (__j < 0) { const auto __match = __first + __i + 1; return std::make_pair(__match, __match + __patlen); } __i += std::max(_M_bad_char_shift(__first[__i]), _M_good_suffix[__j]); } return std::make_pair(__last, __last); } } # 13 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" 2 # 1 "/usr/include/c++/15/ostream" 1 3 # 42 "/usr/include/c++/15/ostream" 3 # 1 "/usr/include/c++/15/bits/ostream.h" 1 3 # 43 "/usr/include/c++/15/bits/ostream.h" 3 # 1 "/usr/include/c++/15/ios" 1 3 # 42 "/usr/include/c++/15/ios" 3 # 1 "/usr/include/c++/15/iosfwd" 1 3 # 43 "/usr/include/c++/15/iosfwd" 3 # 1 "/usr/include/c++/15/bits/stringfwd.h" 1 3 # 44 "/usr/include/c++/15/bits/stringfwd.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct char_traits; template<> struct char_traits; template<> struct char_traits; template<> struct char_traits; template<> struct char_traits; namespace __cxx11 { template, typename _Alloc = allocator<_CharT> > class basic_string; } typedef basic_string string; typedef basic_string wstring; # 91 "/usr/include/c++/15/bits/stringfwd.h" 3 typedef basic_string u16string; typedef basic_string u32string; } # 44 "/usr/include/c++/15/iosfwd" 2 3 # 1 "/usr/include/c++/15/bits/postypes.h" 1 3 # 42 "/usr/include/c++/15/bits/postypes.h" 3 # 1 "/usr/include/c++/15/cwchar" 1 3 # 49 "/usr/include/c++/15/cwchar" 3 # 1 "/usr/include/wchar.h" 1 3 4 # 27 "/usr/include/wchar.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 28 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/floatn.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/floatn.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/long-double.h" 1 3 4 # 24 "/usr/include/riscv64-linux-gnu/bits/floatn.h" 2 3 4 # 95 "/usr/include/riscv64-linux-gnu/bits/floatn.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/floatn-common.h" 1 3 4 # 24 "/usr/include/riscv64-linux-gnu/bits/floatn-common.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/long-double.h" 1 3 4 # 25 "/usr/include/riscv64-linux-gnu/bits/floatn-common.h" 2 3 4 # 96 "/usr/include/riscv64-linux-gnu/bits/floatn.h" 2 3 4 # 31 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 36 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stdarg.h" 1 3 4 # 40 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stdarg.h" 3 4 typedef __builtin_va_list __gnuc_va_list; # 39 "/usr/include/wchar.h" 2 3 4 typedef __gnuc_va_list va_list; # 52 "/usr/include/wchar.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/wint_t.h" 1 3 4 # 20 "/usr/include/riscv64-linux-gnu/bits/types/wint_t.h" 3 4 typedef unsigned int wint_t; # 53 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/mbstate_t.h" 1 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4 # 13 "/usr/include/riscv64-linux-gnu/bits/types/__mbstate_t.h" 3 4 typedef struct { int __count; union { unsigned int __wch; char __wchb[4]; } __value; } __mbstate_t; # 5 "/usr/include/riscv64-linux-gnu/bits/types/mbstate_t.h" 2 3 4 typedef __mbstate_t mbstate_t; # 54 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/__FILE.h" 1 3 4 struct _IO_FILE; typedef struct _IO_FILE __FILE; # 55 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/FILE.h" 1 3 4 struct _IO_FILE; typedef struct _IO_FILE FILE; # 58 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/locale_t.h" 1 3 4 # 22 "/usr/include/riscv64-linux-gnu/bits/types/locale_t.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/__locale_t.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/types/__locale_t.h" 3 4 struct __locale_struct { struct __locale_data *__locales[13]; const unsigned short int *__ctype_b; const int *__ctype_tolower; const int *__ctype_toupper; const char *__names[13]; }; typedef struct __locale_struct *__locale_t; # 23 "/usr/include/riscv64-linux-gnu/bits/types/locale_t.h" 2 3 4 typedef __locale_t locale_t; # 61 "/usr/include/wchar.h" 2 3 4 # 90 "/usr/include/wchar.h" 3 4 extern "C" { struct tm; extern wchar_t *wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern wchar_t *wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern size_t wcslcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); extern size_t wcslcat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); extern wchar_t *wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern wchar_t *wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) noexcept (true); extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, locale_t __loc) noexcept (true); extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, size_t __n, locale_t __loc) noexcept (true); extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); extern size_t wcsxfrm (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true); extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, locale_t __loc) noexcept (true); extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, size_t __n, locale_t __loc) noexcept (true); extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1))); extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc) noexcept (true) __asm ("wcschr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) noexcept (true) __asm ("wcschr") __attribute__ ((__pure__)); extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc) noexcept (true) __asm ("wcsrchr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) noexcept (true) __asm ("wcsrchr") __attribute__ ((__pure__)); # 206 "/usr/include/wchar.h" 3 4 extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) noexcept (true) __attribute__ ((__pure__)); extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) noexcept (true) __attribute__ ((__pure__)); extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) noexcept (true) __attribute__ ((__pure__)); extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept) noexcept (true) __asm ("wcspbrk") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) noexcept (true) __asm ("wcspbrk") __attribute__ ((__pure__)); extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle) noexcept (true) __asm ("wcsstr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) noexcept (true) __asm ("wcsstr") __attribute__ ((__pure__)); extern wchar_t *wcstok (wchar_t *__restrict __s, const wchar_t *__restrict __delim, wchar_t **__restrict __ptr) noexcept (true); extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle) noexcept (true) __asm ("wcswcs") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) noexcept (true) __asm ("wcswcs") __attribute__ ((__pure__)); # 265 "/usr/include/wchar.h" 3 4 extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) noexcept (true) __attribute__ ((__pure__)); extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true) __asm ("wmemchr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) noexcept (true) __asm ("wmemchr") __attribute__ ((__pure__)); extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)); extern wchar_t *wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true); extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) noexcept (true); extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); extern wchar_t *wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true); extern wint_t btowc (int __c) noexcept (true); extern int wctob (wint_t __c) noexcept (true); extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); extern size_t mbrtowc (wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n, mbstate_t *__restrict __p) noexcept (true); extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps) noexcept (true); extern size_t __mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true); extern size_t mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true); extern wint_t __btowc_alias (int __c) __asm ("btowc"); extern __inline __attribute__ ((__gnu_inline__)) wint_t __attribute__ ((__leaf__)) btowc (int __c) noexcept (true) { return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' ? (wint_t) __c : __btowc_alias (__c)); } extern int __wctob_alias (wint_t __c) __asm ("wctob"); extern __inline __attribute__ ((__gnu_inline__)) int __attribute__ ((__leaf__)) wctob (wint_t __wc) noexcept (true) { return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' ? (int) __wc : __wctob_alias (__wc)); } extern __inline __attribute__ ((__gnu_inline__)) size_t __attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) { return (__ps != __null ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } extern size_t mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true); extern size_t wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true); extern size_t mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) noexcept (true); extern size_t wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) noexcept (true); extern int wcwidth (wchar_t __c) noexcept (true); extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); extern double wcstod (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); extern float wcstof (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); extern long double wcstold (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); # 422 "/usr/include/wchar.h" 3 4 extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); extern _Float128 wcstof128 (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) noexcept (true); # 455 "/usr/include/wchar.h" 3 4 extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true); extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true); __extension__ extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true); __extension__ extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true); __extension__ extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true); __extension__ extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true); extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol") ; extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul") ; __extension__ extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll") ; __extension__ extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull") ; __extension__ extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll") ; __extension__ extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull") ; # 561 "/usr/include/wchar.h" 3 4 extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true); extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true); __extension__ extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true); __extension__ extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true); extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l") ; extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l") ; __extension__ extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l") ; __extension__ extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l") ; # 630 "/usr/include/wchar.h" 3 4 extern double wcstod_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); extern float wcstof_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); extern long double wcstold_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); # 649 "/usr/include/wchar.h" 3 4 extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) noexcept (true); # 689 "/usr/include/wchar.h" 3 4 extern wchar_t *wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) noexcept (true); extern wchar_t *wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true); # 718 "/usr/include/wchar.h" 3 4 extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) __attribute__ ((__malloc__)) ; extern int fwide (__FILE *__fp, int __mode) noexcept (true); extern int fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) ; extern int wprintf (const wchar_t *__restrict __format, ...) ; extern int swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __format, ...) noexcept (true) ; extern int vfwprintf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vwprintf (const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) ; extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) ; extern int wscanf (const wchar_t *__restrict __format, ...) ; extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) ; # 795 "/usr/include/wchar.h" 3 4 extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") ; extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") ; extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") ; # 851 "/usr/include/wchar.h" 3 4 extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) ; # 875 "/usr/include/wchar.h" 3 4 extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") ; extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") ; extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") ; # 935 "/usr/include/wchar.h" 3 4 extern wint_t fgetwc (__FILE *__stream); extern wint_t getwc (__FILE *__stream); extern wint_t getwchar (void); extern wint_t fputwc (wchar_t __wc, __FILE *__stream); extern wint_t putwc (wchar_t __wc, __FILE *__stream); extern wint_t putwchar (wchar_t __wc); extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, __FILE *__restrict __stream); extern int fputws (const wchar_t *__restrict __ws, __FILE *__restrict __stream); extern wint_t ungetwc (wint_t __wc, __FILE *__stream); # 990 "/usr/include/wchar.h" 3 4 extern wint_t getwc_unlocked (__FILE *__stream); extern wint_t getwchar_unlocked (void); extern wint_t fgetwc_unlocked (__FILE *__stream); extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); # 1016 "/usr/include/wchar.h" 3 4 extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); extern wint_t putwchar_unlocked (wchar_t __wc); # 1026 "/usr/include/wchar.h" 3 4 extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, __FILE *__restrict __stream); extern int fputws_unlocked (const wchar_t *__restrict __ws, __FILE *__restrict __stream); extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, const wchar_t *__restrict __format, const struct tm *__restrict __tp) noexcept (true); extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, const wchar_t *__restrict __format, const struct tm *__restrict __tp, locale_t __loc) noexcept (true); # 1 "/usr/include/riscv64-linux-gnu/bits/wchar2-decl.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/wchar2-decl.h" 3 4 extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) noexcept (true); extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true) __asm__ ("" "wmemcpy") ; extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) noexcept (true) __asm__ ("" "__wmemcpy_chk") __attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer"))) ; extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1) noexcept (true); extern wchar_t *__wmemmove_alias (wchar_t *__s1, const wchar_t *__s2, size_t __n) noexcept (true) __asm__ ("" "wmemmove") ; extern wchar_t *__wmemmove_chk_warn (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1) noexcept (true) __asm__ ("" "__wmemmove_chk") __attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer"))) ; extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) noexcept (true); extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true) __asm__ ("" "wmempcpy") ; extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) noexcept (true) __asm__ ("" "__wmempcpy_chk") __attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer"))) ; extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) noexcept (true); extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true) __asm__ ("" "wmemset") ; extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) noexcept (true) __asm__ ("" "__wmemset_chk") __attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer"))) ; extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true); extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) noexcept (true) __asm__ ("" "wcscpy") ; extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __destlen) noexcept (true); extern wchar_t *__wcpcpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) noexcept (true) __asm__ ("" "wcpcpy") ; extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true); extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __asm__ ("" "wcsncpy") ; extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true) __asm__ ("" "__wcsncpy_chk") __attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer"))) ; extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true); extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __asm__ ("" "wcpncpy") ; extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true) __asm__ ("" "__wcpncpy_chk") __attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer"))) ; extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __destlen) noexcept (true); extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) noexcept (true) __asm__ ("" "wcscat") ; extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true); extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) __asm__ ("" "wcsncat") ; extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n, int __flag, size_t __s_len, const wchar_t *__restrict __format, ...) noexcept (true) ; extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) noexcept (true) __asm__ ("" "swprintf") ; extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, int __flag, size_t __s_len, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) ; extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) __asm__ ("" "vswprintf") ; extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag, const wchar_t *__restrict __format, ...); extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format, ...); extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag, const wchar_t *__restrict __format, __gnuc_va_list __ap); extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format, __gnuc_va_list __ap); extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws") __attribute__ ((__warn_unused_result__)); extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer"))) ; extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked") __attribute__ ((__warn_unused_result__)); extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer"))) ; extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __p, size_t __buflen) noexcept (true) __attribute__ ((__warn_unused_result__)); extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) noexcept (true) __asm__ ("" "wcrtomb") __attribute__ ((__warn_unused_result__)); extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true); extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true) __asm__ ("" "mbsrtowcs") ; extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true) __asm__ ("" "__mbsrtowcs_chk") __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"))) ; extern size_t __wcsrtombs_chk (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true); extern size_t __wcsrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true) __asm__ ("" "wcsrtombs") ; extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true) __asm__ ("" "__wcsrtombs_chk") __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len"))); extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true); extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) noexcept (true) __asm__ ("" "mbsnrtowcs") ; extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true) __asm__ ("" "__mbsnrtowcs_chk") __attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"))) ; extern size_t __wcsnrtombs_chk (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true); extern size_t __wcsnrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) noexcept (true) __asm__ ("" "wcsnrtombs") ; extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true) __asm__ ("" "__wcsnrtombs_chk") __attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len"))); extern size_t __wcslcpy_chk (wchar_t *__dest, const wchar_t *__src, size_t __n, size_t __destlen) noexcept (true); extern size_t __wcslcpy_alias (wchar_t *__dest, const wchar_t *__src, size_t __n) noexcept (true) __asm__ ("" "wcslcpy") ; extern size_t __wcslcat_chk (wchar_t *__dest, const wchar_t *__src, size_t __n, size_t __destlen) noexcept (true); extern size_t __wcslcat_alias (wchar_t *__dest, const wchar_t *__src, size_t __n) noexcept (true) __asm__ ("" "wcslcat") ; # 1060 "/usr/include/wchar.h" 2 3 4 # 1070 "/usr/include/wchar.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wchar2.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/wchar2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wmemcpy (wchar_t * __restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__s1, 0)) && (__builtin_dynamic_object_size (__s1, 0)) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s1, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s1, 0))) / ((sizeof (wchar_t)))))) ? __wmemcpy_alias (__s1, __s2, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t)))) ? __wmemcpy_chk_warn (__s1, __s2, __n, (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t))) : __wmemcpy_chk (__s1, __s2, __n, (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wmemmove (wchar_t * __s1, const wchar_t *__s2, size_t __n) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__s1, 0)) && (__builtin_dynamic_object_size (__s1, 0)) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s1, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s1, 0))) / ((sizeof (wchar_t)))))) ? __wmemmove_alias (__s1, __s2, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t)))) ? __wmemmove_chk_warn (__s1, __s2, __n, (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t))) : __wmemmove_chk (__s1, __s2, __n, (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wmempcpy (wchar_t * __restrict __s1, const wchar_t *__restrict __s2, size_t __n) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__s1, 0)) && (__builtin_dynamic_object_size (__s1, 0)) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s1, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s1, 0))) / ((sizeof (wchar_t)))))) ? __wmempcpy_alias (__s1, __s2, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t)))) ? __wmempcpy_chk_warn (__s1, __s2, __n, (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t))) : __wmempcpy_chk (__s1, __s2, __n, (__builtin_dynamic_object_size (__s1, 0)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wmemset (wchar_t * __s, wchar_t __c, size_t __n) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__s, 0)) && (__builtin_dynamic_object_size (__s, 0)) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__s, 0))) / ((sizeof (wchar_t)))))) ? __wmemset_alias (__s, __c, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s, 0)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__s, 0)) / (sizeof (wchar_t)))) ? __wmemset_chk_warn (__s, __c, __n, (__builtin_dynamic_object_size (__s, 0)) / (sizeof (wchar_t))) : __wmemset_chk (__s, __c, __n, (__builtin_dynamic_object_size (__s, 0)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wcscpy (wchar_t * __restrict __dest, const wchar_t *__restrict __src) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__dest, 1); if (__sz != (size_t) -1) return __wcscpy_chk (__dest, __src, __sz / sizeof (wchar_t)); return __wcscpy_alias (__dest, __src); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wcpcpy (wchar_t * __restrict __dest, const wchar_t *__restrict __src) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__dest, 1); if (__sz != (size_t) -1) return __wcpcpy_chk (__dest, __src, __sz / sizeof (wchar_t)); return __wcpcpy_alias (__dest, __src); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wcsncpy (wchar_t * __restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dest, 1)) && (__builtin_dynamic_object_size (__dest, 1)) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__dest, 1))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__dest, 1))) / ((sizeof (wchar_t)))))) ? __wcsncpy_alias (__dest, __src, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t)))) ? __wcsncpy_chk_warn (__dest, __src, __n, (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t))) : __wcsncpy_chk (__dest, __src, __n, (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wcpncpy (wchar_t * __restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dest, 1)) && (__builtin_dynamic_object_size (__dest, 1)) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__dest, 1))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__builtin_dynamic_object_size (__dest, 1))) / ((sizeof (wchar_t)))))) ? __wcpncpy_alias (__dest, __src, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t)))) ? __wcpncpy_chk_warn (__dest, __src, __n, (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t))) : __wcpncpy_chk (__dest, __src, __n, (__builtin_dynamic_object_size (__dest, 1)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wcscat (wchar_t * __restrict __dest, const wchar_t *__restrict __src) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__dest, 1); if (__sz != (size_t) -1) return __wcscat_chk (__dest, __src, __sz / sizeof (wchar_t)); return __wcscat_alias (__dest, __src); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t * __attribute__ ((__leaf__)) wcsncat (wchar_t * __restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__dest, 1); if (__sz != (size_t) -1) return __wcsncat_chk (__dest, __src, __n, __sz / sizeof (wchar_t)); return __wcsncat_alias (__dest, __src, __n); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) wcslcpy (wchar_t * __restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) { if (__builtin_dynamic_object_size (__dest, 1) != (size_t) -1 && (!__builtin_constant_p (__n > __builtin_dynamic_object_size (__dest, 1) / sizeof (wchar_t)) || __n > __builtin_dynamic_object_size (__dest, 1) / sizeof (wchar_t))) return __wcslcpy_chk (__dest, __src, __n, __builtin_dynamic_object_size (__dest, 1) / sizeof (wchar_t)); return __wcslcpy_alias (__dest, __src, __n); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) wcslcat (wchar_t * __restrict __dest, const wchar_t *__restrict __src, size_t __n) noexcept (true) { if (__builtin_dynamic_object_size (__dest, 1) != (size_t) -1 && (!__builtin_constant_p (__n > __builtin_dynamic_object_size (__dest, 1) / sizeof (wchar_t)) || __n > __builtin_dynamic_object_size (__dest, 1) / sizeof (wchar_t))) return __wcslcat_chk (__dest, __src, __n, __builtin_dynamic_object_size (__dest, 1) / sizeof (wchar_t)); return __wcslcat_alias (__dest, __src, __n); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__s, 1); if (__sz != (size_t) -1 || 3 > 1) return __swprintf_chk (__s, __n, 3 - 1, __sz / sizeof (wchar_t), __fmt, __builtin_va_arg_pack ()); return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ()); } # 205 "/usr/include/riscv64-linux-gnu/bits/wchar2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__s, 1); if (__sz != (size_t) -1 || 3 > 1) return __vswprintf_chk (__s, __n, 3 - 1, __sz / sizeof (wchar_t), __fmt, __ap); return __vswprintf_alias (__s, __n, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int wprintf (const wchar_t *__restrict __fmt, ...) { return __wprintf_chk (3 - 1, __fmt, __builtin_va_arg_pack ()); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...) { return __fwprintf_chk (__stream, 3 - 1, __fmt, __builtin_va_arg_pack ()); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap) { return __vwprintf_chk (3 - 1, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int vfwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) { return __vfwprintf_chk (__stream, 3 - 1, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t * fgetws (wchar_t * __restrict __s, int __n, __FILE *__restrict __stream) { size_t __sz = __builtin_dynamic_object_size (__s, 1); if (((__builtin_constant_p (__sz) && (__sz) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (wchar_t))))))) return __fgetws_alias (__s, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__sz) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__sz) / (sizeof (wchar_t))))) return __fgetws_chk_warn (__s, __sz / sizeof (wchar_t), __n, __stream); return __fgetws_chk (__s, __sz / sizeof (wchar_t), __n, __stream); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t * fgetws_unlocked (wchar_t * __restrict __s, int __n, __FILE *__restrict __stream) { size_t __sz = __builtin_dynamic_object_size (__s, 1); if (((__builtin_constant_p (__sz) && (__sz) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (wchar_t))))))) return __fgetws_unlocked_alias (__s, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__sz) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <= (__sz) / (sizeof (wchar_t))))) return __fgetws_unlocked_chk_warn (__s, __sz / sizeof (wchar_t), __n, __stream); return __fgetws_unlocked_chk (__s, __sz / sizeof (wchar_t), __n, __stream); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t __attribute__ ((__leaf__)) wcrtomb (char * __restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) noexcept (true) { if (__builtin_dynamic_object_size (__s, 1) != (size_t) -1 && 16 > __builtin_dynamic_object_size (__s, 1)) return __wcrtomb_chk (__s, __wchar, __ps, __builtin_dynamic_object_size (__s, 1)); return __wcrtomb_alias (__s, __wchar, __ps); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) mbsrtowcs (wchar_t * __restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dst, 1)) && (__builtin_dynamic_object_size (__dst, 1)) == (long unsigned int) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (wchar_t)))))) ? __mbsrtowcs_alias (__dst, __src, __len, __ps) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t)))) ? __mbsrtowcs_chk_warn (__dst, __src, __len, __ps, (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t))) : __mbsrtowcs_chk (__dst, __src, __len, __ps, (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) wcsrtombs (char * __restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dst, 1)) && (__builtin_dynamic_object_size (__dst, 1)) == (long unsigned int) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (char))))) && (((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (char)))))) ? __wcsrtombs_alias (__dst, __src, __len, __ps) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (char)))) && !(((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (char)))) ? __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin_dynamic_object_size (__dst, 1)) : __wcsrtombs_chk (__dst, __src, __len, __ps, __builtin_dynamic_object_size (__dst, 1)))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) mbsnrtowcs (wchar_t * __restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dst, 1)) && (__builtin_dynamic_object_size (__dst, 1)) == (long unsigned int) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (wchar_t)))))) ? __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t)))) ? __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps, (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t))) : __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t))))) ; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) wcsnrtombs (char * __restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dst, 1)) && (__builtin_dynamic_object_size (__dst, 1)) == (long unsigned int) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (char))))) && (((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (char)))))) ? __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (char)))) && !(((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (char)))) ? __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps, __builtin_dynamic_object_size (__dst, 1)) : __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, __builtin_dynamic_object_size (__dst, 1)))) ; } # 1071 "/usr/include/wchar.h" 2 3 4 } # 50 "/usr/include/c++/15/cwchar" 2 3 # 64 "/usr/include/c++/15/cwchar" 3 namespace std { using ::mbstate_t; } # 137 "/usr/include/c++/15/cwchar" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { 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 ::mbsinit; using ::mbsrtowcs; using ::putwc; using ::putwchar; using ::swprintf; using ::swscanf; using ::ungetwc; using ::vfwprintf; using ::vfwscanf; using ::vswprintf; using ::vswscanf; using ::vwprintf; using ::vwscanf; using ::wcrtomb; using ::wcscat; using ::wcscmp; using ::wcscoll; using ::wcscpy; using ::wcscspn; using ::wcsftime; using ::wcslen; using ::wcsncat; using ::wcsncmp; using ::wcsncpy; using ::wcsrtombs; using ::wcsspn; using ::wcstod; using ::wcstof; using ::wcstok; using ::wcstol; using ::wcstoul; using ::wcsxfrm; using ::wctob; using ::wmemcmp; using ::wmemcpy; using ::wmemmove; using ::wmemset; using ::wprintf; using ::wscanf; using ::wcschr; using ::wcspbrk; using ::wcsrchr; using ::wcsstr; using ::wmemchr; # 236 "/usr/include/c++/15/cwchar" 3 } } namespace __gnu_cxx { using ::wcstold; # 262 "/usr/include/c++/15/cwchar" 3 using ::wcstoll; using ::wcstoull; } namespace std { using ::__gnu_cxx::wcstold; using ::__gnu_cxx::wcstoll; using ::__gnu_cxx::wcstoull; } # 282 "/usr/include/c++/15/cwchar" 3 namespace std { using std::wcstof; using std::vfwscanf; using std::vswscanf; using std::vwscanf; using std::wcstold; using std::wcstoll; using std::wcstoull; } # 43 "/usr/include/c++/15/bits/postypes.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 55 "/usr/include/c++/15/bits/postypes.h" 3 # 55 "/usr/include/c++/15/bits/postypes.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" # 66 "/usr/include/c++/15/bits/postypes.h" 3 typedef long int streamoff; #pragma GCC diagnostic pop typedef ptrdiff_t streamsize; # 86 "/usr/include/c++/15/bits/postypes.h" 3 template class fpos { private: streamoff _M_off; _StateT _M_state; public: fpos() : _M_off(0), _M_state() { } # 108 "/usr/include/c++/15/bits/postypes.h" 3 fpos(streamoff __off) : _M_off(__off), _M_state() { } fpos(const fpos&) = default; fpos& operator=(const fpos&) = default; ~fpos() = default; operator streamoff() const { return _M_off; } void state(_StateT __st) { _M_state = __st; } _StateT state() const { return _M_state; } fpos& operator+=(streamoff __off) { _M_off += __off; return *this; } fpos& operator-=(streamoff __off) { _M_off -= __off; return *this; } fpos operator+(streamoff __off) const { fpos __pos(*this); __pos += __off; return __pos; } fpos operator-(streamoff __off) const { fpos __pos(*this); __pos -= __off; return __pos; } streamoff operator-(const fpos& __other) const { return _M_off - __other._M_off; } }; template inline bool operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) { return streamoff(__lhs) == streamoff(__rhs); } template inline bool operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) { return streamoff(__lhs) != streamoff(__rhs); } typedef fpos streampos; typedef fpos wstreampos; # 220 "/usr/include/c++/15/bits/postypes.h" 3 typedef fpos u16streampos; typedef fpos u32streampos; } # 45 "/usr/include/c++/15/iosfwd" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 78 "/usr/include/c++/15/iosfwd" 3 class ios_base; template > class basic_ios; template > class basic_streambuf; template > class basic_istream; template > class basic_ostream; template > class basic_iostream; namespace __cxx11 { template, typename _Alloc = allocator<_CharT> > class basic_stringbuf; template, typename _Alloc = allocator<_CharT> > class basic_istringstream; template, typename _Alloc = allocator<_CharT> > class basic_ostringstream; template, typename _Alloc = allocator<_CharT> > class basic_stringstream; } template > class basic_filebuf; template > class basic_ifstream; template > class basic_ofstream; template > class basic_fstream; template > class istreambuf_iterator; template > class ostreambuf_iterator; typedef basic_ios ios; typedef basic_streambuf streambuf; typedef basic_istream istream; typedef basic_ostream ostream; typedef basic_iostream iostream; typedef basic_stringbuf stringbuf; typedef basic_istringstream istringstream; typedef basic_ostringstream ostringstream; typedef basic_stringstream stringstream; typedef basic_filebuf filebuf; typedef basic_ifstream ifstream; typedef basic_ofstream ofstream; typedef basic_fstream fstream; typedef basic_ios wios; typedef basic_streambuf wstreambuf; typedef basic_istream wistream; typedef basic_ostream wostream; typedef basic_iostream wiostream; typedef basic_stringbuf wstringbuf; typedef basic_istringstream wistringstream; typedef basic_ostringstream wostringstream; typedef basic_stringstream wstringstream; typedef basic_filebuf wfilebuf; typedef basic_ifstream wifstream; typedef basic_ofstream wofstream; typedef basic_fstream wfstream; # 257 "/usr/include/c++/15/iosfwd" 3 } # 43 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/exception" 1 3 # 41 "/usr/include/c++/15/exception" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 42 "/usr/include/c++/15/exception" 2 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { # 56 "/usr/include/c++/15/exception" 3 class bad_exception : public exception { public: bad_exception() noexcept { } virtual ~bad_exception() noexcept; virtual const char* what() const noexcept; }; typedef void (*terminate_handler) (); terminate_handler set_terminate(terminate_handler) noexcept; terminate_handler get_terminate() noexcept; void terminate() noexcept __attribute__ ((__noreturn__,__cold__)); typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); __attribute__ ((__deprecated__)) unexpected_handler set_unexpected(unexpected_handler) noexcept; __attribute__ ((__deprecated__)) unexpected_handler get_unexpected() noexcept; __attribute__ ((__deprecated__)) void unexpected() __attribute__ ((__noreturn__,__cold__)); # 126 "/usr/include/c++/15/exception" 3 __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) bool uncaught_exception() noexcept __attribute__ ((__pure__)); int uncaught_exceptions() noexcept __attribute__ ((__pure__)); } namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 160 "/usr/include/c++/15/exception" 3 void __verbose_terminate_handler(); } } # 1 "/usr/include/c++/15/bits/exception_ptr.h" 1 3 # 36 "/usr/include/c++/15/bits/exception_ptr.h" 3 # 1 "/usr/include/c++/15/bits/cxxabi_init_exception.h" 1 3 # 38 "/usr/include/c++/15/bits/cxxabi_init_exception.h" 3 #pragma GCC visibility push(default) # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 41 "/usr/include/c++/15/bits/cxxabi_init_exception.h" 2 3 # 52 "/usr/include/c++/15/bits/cxxabi_init_exception.h" 3 namespace std { class type_info; } namespace __cxxabiv1 { struct __cxa_refcounted_exception; extern "C" { void* __cxa_allocate_exception(size_t) noexcept; void __cxa_free_exception(void*) noexcept; __cxa_refcounted_exception* __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, void ( *__dest) (void *)) noexcept; } } #pragma GCC visibility pop # 37 "/usr/include/c++/15/bits/exception_ptr.h" 2 3 # 50 "/usr/include/c++/15/bits/exception_ptr.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { class type_info; namespace __exception_ptr { class exception_ptr; } using __exception_ptr::exception_ptr; # 75 "/usr/include/c++/15/bits/exception_ptr.h" 3 exception_ptr current_exception() noexcept; template exception_ptr make_exception_ptr(_Ex) noexcept; void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); namespace __exception_ptr { using std::rethrow_exception; # 97 "/usr/include/c++/15/bits/exception_ptr.h" 3 class exception_ptr { void* _M_exception_object; explicit exception_ptr(void* __e) noexcept; void _M_addref() noexcept; void _M_release() noexcept; void *_M_get() const noexcept __attribute__ ((__pure__)); friend exception_ptr std::current_exception() noexcept; friend void std::rethrow_exception(exception_ptr); template friend exception_ptr std::make_exception_ptr(_Ex) noexcept; public: exception_ptr() noexcept; exception_ptr(const exception_ptr&) noexcept; exception_ptr(nullptr_t) noexcept : _M_exception_object(nullptr) { } exception_ptr(exception_ptr&& __o) noexcept : _M_exception_object(__o._M_exception_object) { __o._M_exception_object = nullptr; } # 135 "/usr/include/c++/15/bits/exception_ptr.h" 3 exception_ptr& operator=(const exception_ptr&) noexcept; exception_ptr& operator=(exception_ptr&& __o) noexcept { exception_ptr(static_cast(__o)).swap(*this); return *this; } ~exception_ptr() noexcept; void swap(exception_ptr&) noexcept; # 161 "/usr/include/c++/15/bits/exception_ptr.h" 3 explicit operator bool() const noexcept { return _M_exception_object; } friend bool operator==(const exception_ptr& __x, const exception_ptr& __y) noexcept { return __x._M_exception_object == __y._M_exception_object; } friend bool operator!=(const exception_ptr& __x, const exception_ptr& __y) noexcept { return __x._M_exception_object != __y._M_exception_object; } const class std::type_info* __cxa_exception_type() const noexcept __attribute__ ((__pure__)); }; inline exception_ptr::exception_ptr() noexcept : _M_exception_object(0) { } inline exception_ptr::exception_ptr(const exception_ptr& __other) noexcept : _M_exception_object(__other._M_exception_object) { if (_M_exception_object) _M_addref(); } inline exception_ptr::~exception_ptr() noexcept { if (_M_exception_object) _M_release(); } inline exception_ptr& exception_ptr::operator=(const exception_ptr& __other) noexcept { exception_ptr(__other).swap(*this); return *this; } inline void exception_ptr::swap(exception_ptr &__other) noexcept { void *__tmp = _M_exception_object; _M_exception_object = __other._M_exception_object; __other._M_exception_object = __tmp; } inline void swap(exception_ptr& __lhs, exception_ptr& __rhs) { __lhs.swap(__rhs); } template inline void __dest_thunk(void* __x) { static_cast<_Ex*>(__x)->~_Ex(); } } using __exception_ptr::swap; template exception_ptr make_exception_ptr(_Ex __ex) noexcept { using _Ex2 = typename decay<_Ex>::type; void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); (void) __cxxabiv1::__cxa_init_primary_exception( __e, const_cast(&typeid(_Ex)), __exception_ptr::__dest_thunk<_Ex2>); try { ::new (__e) _Ex2(__ex); return exception_ptr(__e); } catch(...) { __cxxabiv1::__cxa_free_exception(__e); return current_exception(); } # 276 "/usr/include/c++/15/bits/exception_ptr.h" 3 } # 290 "/usr/include/c++/15/bits/exception_ptr.h" 3 } } # 169 "/usr/include/c++/15/exception" 2 3 # 1 "/usr/include/c++/15/bits/nested_exception.h" 1 3 # 40 "/usr/include/c++/15/bits/nested_exception.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { # 59 "/usr/include/c++/15/bits/nested_exception.h" 3 class nested_exception { exception_ptr _M_ptr; public: nested_exception() noexcept : _M_ptr(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 (_M_ptr) rethrow_exception(_M_ptr); std::terminate(); } exception_ptr nested_ptr() const noexcept { return _M_ptr; } }; template struct _Nested_exception : public _Except, public nested_exception { explicit _Nested_exception(const _Except& __ex) : _Except(__ex) { } explicit _Nested_exception(_Except&& __ex) : _Except(static_cast<_Except&&>(__ex)) { } }; # 145 "/usr/include/c++/15/bits/nested_exception.h" 3 template [[noreturn]] inline void throw_with_nested(_Tp&& __t) { using _Up = typename decay<_Tp>::type; using _CopyConstructible = __and_, is_move_constructible<_Up>>; static_assert(_CopyConstructible::value, "throw_with_nested argument must be CopyConstructible"); if constexpr (is_class_v<_Up>) if constexpr (!is_final_v<_Up>) if constexpr (!is_base_of_v) throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; throw std::forward<_Tp>(__t); } # 203 "/usr/include/c++/15/bits/nested_exception.h" 3 template inline void rethrow_if_nested(const _Ex& __ex) { const _Ex* __ptr = __builtin_addressof(__ex); # 223 "/usr/include/c++/15/bits/nested_exception.h" 3 if constexpr (!is_polymorphic_v<_Ex>) return; else if constexpr (is_base_of_v && !is_convertible_v<_Ex*, nested_exception*>) return; else if (auto __ne_ptr = dynamic_cast(__ptr)) __ne_ptr->rethrow_nested(); } } } # 170 "/usr/include/c++/15/exception" 2 3 # 44 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/bits/char_traits.h" 1 3 # 66 "/usr/include/c++/15/bits/char_traits.h" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 70 "/usr/include/c++/15/bits/char_traits.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstringop-overflow" #pragma GCC diagnostic ignored "-Wstringop-overread" #pragma GCC diagnostic ignored "-Warray-bounds" # 85 "/usr/include/c++/15/bits/char_traits.h" 3 template struct _Char_types { typedef unsigned long int_type; typedef std::streampos pos_type; typedef std::streamoff off_type; typedef std::mbstate_t state_type; }; # 112 "/usr/include/c++/15/bits/char_traits.h" 3 template struct char_traits { typedef _CharT char_type; typedef typename _Char_types<_CharT>::int_type int_type; typedef typename _Char_types<_CharT>::pos_type pos_type; typedef typename _Char_types<_CharT>::off_type off_type; typedef typename _Char_types<_CharT>::state_type state_type; static constexpr void assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, std::size_t __n); static constexpr std::size_t length(const char_type* __s); static constexpr const char_type* find(const char_type* __s, std::size_t __n, const char_type& __a); static char_type* move(char_type* __s1, const char_type* __s2, std::size_t __n); static char_type* copy(char_type* __s1, const char_type* __s2, std::size_t __n); static char_type* assign(char_type* __s, std::size_t __n, char_type __a); static constexpr char_type to_char_type(const int_type& __c) { return static_cast(__c); } static constexpr int_type to_int_type(const char_type& __c) { return static_cast(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } static constexpr int_type eof() { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } }; template constexpr int char_traits<_CharT>:: compare(const char_type* __s1, const char_type* __s2, std::size_t __n) { for (std::size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) return -1; else if (lt(__s2[__i], __s1[__i])) return 1; return 0; } template constexpr std::size_t char_traits<_CharT>:: length(const char_type* __p) { std::size_t __i = 0; while (!eq(__p[__i], char_type())) ++__i; return __i; } template constexpr const typename char_traits<_CharT>::char_type* char_traits<_CharT>:: find(const char_type* __s, std::size_t __n, const char_type& __a) { for (std::size_t __i = 0; __i < __n; ++__i) if (eq(__s[__i], __a)) return __s + __i; return 0; } template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: move(char_type* __s1, const char_type* __s2, std::size_t __n) { if (__n == 0) return __s1; # 248 "/usr/include/c++/15/bits/char_traits.h" 3 __builtin_memmove(__s1, __s2, __n * sizeof(char_type)); return __s1; } template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: copy(char_type* __s1, const char_type* __s2, std::size_t __n) { if (__n == 0) return __s1; # 268 "/usr/include/c++/15/bits/char_traits.h" 3 __builtin_memcpy(__s1, __s2, __n * sizeof(char_type)); return __s1; } template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: assign(char_type* __s, std::size_t __n, char_type __a) { # 287 "/usr/include/c++/15/bits/char_traits.h" 3 if constexpr (sizeof(_CharT) == 1 && __is_trivial(_CharT)) { if (__n) { unsigned char __c; __builtin_memcpy(&__c, __builtin_addressof(__a), 1); __builtin_memset(__s, __c, __n); } } else { for (std::size_t __i = 0; __i < __n; ++__i) __s[__i] = __a; } return __s; } } namespace std __attribute__ ((__visibility__ ("default"))) { # 324 "/usr/include/c++/15/bits/char_traits.h" 3 template struct char_traits : public __gnu_cxx::char_traits<_CharT> { }; template<> struct char_traits { typedef char char_type; typedef int int_type; typedef streampos pos_type; typedef streamoff off_type; typedef mbstate_t state_type; static constexpr void assign(char_type& __c1, const char_type& __c2) noexcept { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) noexcept { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) noexcept { return (static_cast(__c1) < static_cast(__c2)); } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return 0; if (std::__is_constant_evaluated()) { for (size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) return -1; else if (lt(__s2[__i], __s1[__i])) return 1; return 0; } return __builtin_memcmp(__s1, __s2, __n); } static constexpr size_t length(const char_type* __s) { if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::length(__s); return __builtin_strlen(__s); } static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a) { if (__n == 0) return 0; if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::find(__s, __n, __a); return static_cast(__builtin_memchr(__s, __a, __n)); } static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return static_cast(__builtin_memmove(__s1, __s2, __n)); } static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return static_cast(__builtin_memcpy(__s1, __s2, __n)); } static char_type* assign(char_type* __s, size_t __n, char_type __a) { if (__n == 0) return __s; return static_cast(__builtin_memset(__s, __a, __n)); } static constexpr char_type to_char_type(const int_type& __c) noexcept { return static_cast(__c); } static constexpr int_type to_int_type(const char_type& __c) noexcept { return static_cast(static_cast(__c)); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type eof() noexcept { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return (__c == eof()) ? 0 : __c; } }; template<> struct char_traits { typedef wchar_t char_type; typedef wint_t int_type; typedef streamoff off_type; typedef wstreampos pos_type; typedef mbstate_t state_type; static constexpr void assign(char_type& __c1, const char_type& __c2) noexcept { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) noexcept { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) noexcept { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return 0; if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::compare(__s1, __s2, __n); return wmemcmp(__s1, __s2, __n); } static constexpr size_t length(const char_type* __s) { if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::length(__s); return wcslen(__s); } static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a) { if (__n == 0) return 0; if (std::__is_constant_evaluated()) return __gnu_cxx::char_traits::find(__s, __n, __a); return wmemchr(__s, __a, __n); } static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return wmemmove(__s1, __s2, __n); } static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return wmemcpy(__s1, __s2, __n); } static char_type* assign(char_type* __s, size_t __n, char_type __a) { if (__n == 0) return __s; return wmemset(__s, __a, __n); } static constexpr char_type to_char_type(const int_type& __c) noexcept { return char_type(__c); } static constexpr int_type to_int_type(const char_type& __c) noexcept { return int_type(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type eof() noexcept { return static_cast((0xffffffffu)); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; # 731 "/usr/include/c++/15/bits/char_traits.h" 3 } namespace std __attribute__ ((__visibility__ ("default"))) { template<> struct char_traits { typedef char16_t char_type; typedef short unsigned int int_type; typedef streamoff off_type; typedef u16streampos pos_type; typedef mbstate_t state_type; static constexpr void assign(char_type& __c1, const char_type& __c2) noexcept { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) noexcept { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) noexcept { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { for (size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) return -1; else if (lt(__s2[__i], __s1[__i])) return 1; return 0; } static constexpr size_t length(const char_type* __s) { size_t __i = 0; while (!eq(__s[__i], char_type())) ++__i; return __i; } static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a) { for (size_t __i = 0; __i < __n; ++__i) if (eq(__s[__i], __a)) return __s + __i; return 0; } static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return (static_cast (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); } static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return (static_cast (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); } static char_type* assign(char_type* __s, size_t __n, char_type __a) { for (size_t __i = 0; __i < __n; ++__i) assign(__s[__i], __a); return __s; } static constexpr char_type to_char_type(const int_type& __c) noexcept { return char_type(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type to_int_type(const char_type& __c) noexcept { return __c == eof() ? int_type(0xfffd) : int_type(__c); } static constexpr int_type eof() noexcept { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; template<> struct char_traits { typedef char32_t char_type; typedef unsigned int int_type; typedef streamoff off_type; typedef u32streampos pos_type; typedef mbstate_t state_type; static constexpr void assign(char_type& __c1, const char_type& __c2) noexcept { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) noexcept { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) noexcept { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { for (size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) return -1; else if (lt(__s2[__i], __s1[__i])) return 1; return 0; } static constexpr size_t length(const char_type* __s) { size_t __i = 0; while (!eq(__s[__i], char_type())) ++__i; return __i; } static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a) { for (size_t __i = 0; __i < __n; ++__i) if (eq(__s[__i], __a)) return __s + __i; return 0; } static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return (static_cast (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); } static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return __s1; return (static_cast (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); } static char_type* assign(char_type* __s, size_t __n, char_type __a) { for (size_t __i = 0; __i < __n; ++__i) assign(__s[__i], __a); return __s; } static constexpr char_type to_char_type(const int_type& __c) noexcept { return char_type(__c); } static constexpr int_type to_int_type(const char_type& __c) noexcept { return int_type(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type eof() noexcept { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; # 1009 "/usr/include/c++/15/bits/char_traits.h" 3 #pragma GCC diagnostic pop } # 45 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/bits/localefwd.h" 1 3 # 42 "/usr/include/c++/15/bits/localefwd.h" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++locale.h" 1 3 # 39 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++locale.h" 3 # 40 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++locale.h" 3 # 1 "/usr/include/c++/15/clocale" 1 3 # 47 "/usr/include/c++/15/clocale" 3 # 1 "/usr/include/locale.h" 1 3 4 # 28 "/usr/include/locale.h" 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 29 "/usr/include/locale.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/locale.h" 1 3 4 # 30 "/usr/include/locale.h" 2 3 4 extern "C" { # 51 "/usr/include/locale.h" 3 4 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; char int_p_cs_precedes; char int_p_sep_by_space; char int_n_cs_precedes; char int_n_sep_by_space; char int_p_sign_posn; char int_n_sign_posn; # 118 "/usr/include/locale.h" 3 4 }; extern char *setlocale (int __category, const char *__locale) noexcept (true); extern struct lconv *localeconv (void) noexcept (true); # 141 "/usr/include/locale.h" 3 4 extern locale_t newlocale (int __category_mask, const char *__locale, locale_t __base) noexcept (true); # 176 "/usr/include/locale.h" 3 4 extern locale_t duplocale (locale_t __dataset) noexcept (true); extern void freelocale (locale_t __dataset) noexcept (true); extern locale_t uselocale (locale_t __dataset) noexcept (true); } # 48 "/usr/include/c++/15/clocale" 2 3 namespace std { using ::lconv; using ::setlocale; using ::localeconv; } # 42 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++locale.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { extern "C" __typeof(uselocale) __uselocale; } namespace std __attribute__ ((__visibility__ ("default"))) { typedef __locale_t __c_locale; # 73 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++locale.h" 3 inline int __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), char* __out, const int __size __attribute__ ((__unused__)), const char* __fmt, ...) { __c_locale __old = __gnu_cxx::__uselocale(__cloc); # 93 "/usr/include/riscv64-linux-gnu/c++/15/bits/c++locale.h" 3 __builtin_va_list __args; __builtin_va_start(__args, __fmt); const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); __builtin_va_end(__args); __gnu_cxx::__uselocale(__old); return __ret; } } # 43 "/usr/include/c++/15/bits/localefwd.h" 2 3 # 1 "/usr/include/c++/15/cctype" 1 3 # 47 "/usr/include/c++/15/cctype" 3 # 1 "/usr/include/ctype.h" 1 3 4 # 28 "/usr/include/ctype.h" 3 4 extern "C" { # 39 "/usr/include/ctype.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/endian.h" 1 3 4 # 35 "/usr/include/riscv64-linux-gnu/bits/endian.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/endianness.h" 1 3 4 # 36 "/usr/include/riscv64-linux-gnu/bits/endian.h" 2 3 4 # 40 "/usr/include/ctype.h" 2 3 4 enum { _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) }; # 79 "/usr/include/ctype.h" 3 4 extern const unsigned short int **__ctype_b_loc (void) noexcept (true) __attribute__ ((__const__)); extern const __int32_t **__ctype_tolower_loc (void) noexcept (true) __attribute__ ((__const__)); extern const __int32_t **__ctype_toupper_loc (void) noexcept (true) __attribute__ ((__const__)); # 108 "/usr/include/ctype.h" 3 4 extern int isalnum (int) noexcept (true); extern int isalpha (int) noexcept (true); extern int iscntrl (int) noexcept (true); extern int isdigit (int) noexcept (true); extern int islower (int) noexcept (true); extern int isgraph (int) noexcept (true); extern int isprint (int) noexcept (true); extern int ispunct (int) noexcept (true); extern int isspace (int) noexcept (true); extern int isupper (int) noexcept (true); extern int isxdigit (int) noexcept (true); extern int tolower (int __c) noexcept (true); extern int toupper (int __c) noexcept (true); extern int isblank (int) noexcept (true); extern int isctype (int __c, int __mask) noexcept (true); extern int isascii (int __c) noexcept (true); extern int toascii (int __c) noexcept (true); extern int _toupper (int) noexcept (true); extern int _tolower (int) noexcept (true); # 251 "/usr/include/ctype.h" 3 4 extern int isalnum_l (int, locale_t) noexcept (true); extern int isalpha_l (int, locale_t) noexcept (true); extern int iscntrl_l (int, locale_t) noexcept (true); extern int isdigit_l (int, locale_t) noexcept (true); extern int islower_l (int, locale_t) noexcept (true); extern int isgraph_l (int, locale_t) noexcept (true); extern int isprint_l (int, locale_t) noexcept (true); extern int ispunct_l (int, locale_t) noexcept (true); extern int isspace_l (int, locale_t) noexcept (true); extern int isupper_l (int, locale_t) noexcept (true); extern int isxdigit_l (int, locale_t) noexcept (true); extern int isblank_l (int, locale_t) noexcept (true); extern int __tolower_l (int __c, locale_t __l) noexcept (true); extern int tolower_l (int __c, locale_t __l) noexcept (true); extern int __toupper_l (int __c, locale_t __l) noexcept (true); extern int toupper_l (int __c, locale_t __l) noexcept (true); # 327 "/usr/include/ctype.h" 3 4 } # 48 "/usr/include/c++/15/cctype" 2 3 # 64 "/usr/include/c++/15/cctype" 3 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; } namespace std { using ::isblank; } # 45 "/usr/include/c++/15/bits/localefwd.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 57 "/usr/include/c++/15/bits/localefwd.h" 3 class locale; template bool has_facet(const locale&) throw(); template const _Facet& use_facet(const locale&); template bool isspace(_CharT, const locale&); template bool isprint(_CharT, const locale&); template bool iscntrl(_CharT, const locale&); template bool isupper(_CharT, const locale&); template bool islower(_CharT, const locale&); template bool isalpha(_CharT, const locale&); template bool isdigit(_CharT, const locale&); template bool ispunct(_CharT, const locale&); template bool isxdigit(_CharT, const locale&); template bool isalnum(_CharT, const locale&); template bool isgraph(_CharT, const locale&); template bool isblank(_CharT, const locale&); template _CharT toupper(_CharT, const locale&); template _CharT tolower(_CharT, const locale&); struct ctype_base; template class ctype; template<> class ctype; template<> class ctype; template class ctype_byname; class codecvt_base; template class codecvt; template<> class codecvt; template<> class codecvt; template<> class codecvt; template<> class codecvt; template class codecvt_byname; template > class num_get; template > class num_put; namespace __cxx11 { template class numpunct; template class numpunct_byname; } namespace __cxx11 { template class collate; template class collate_byname; } class time_base; namespace __cxx11 { template > class time_get; template > class time_get_byname; } template > class time_put; template > class time_put_byname; class money_base; namespace __cxx11 { template > class money_get; template > class money_put; } namespace __cxx11 { template class moneypunct; template class moneypunct_byname; } struct messages_base; namespace __cxx11 { template class messages; template class messages_byname; } } # 46 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/bits/ios_base.h" 1 3 # 41 "/usr/include/c++/15/bits/ios_base.h" 3 # 1 "/usr/include/c++/15/ext/atomicity.h" 1 3 # 37 "/usr/include/c++/15/ext/atomicity.h" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr.h" 1 3 # 30 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr.h" 3 #pragma GCC visibility push(default) # 157 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr.h" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 1 3 # 35 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 # 1 "/usr/include/pthread.h" 1 3 4 # 22 "/usr/include/pthread.h" 3 4 # 1 "/usr/include/sched.h" 1 3 4 # 29 "/usr/include/sched.h" 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 30 "/usr/include/sched.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/time_t.h" 1 3 4 # 10 "/usr/include/riscv64-linux-gnu/bits/types/time_t.h" 3 4 typedef __time_t time_t; # 32 "/usr/include/sched.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_timespec.h" 1 3 4 # 11 "/usr/include/riscv64-linux-gnu/bits/types/struct_timespec.h" 3 4 struct timespec { __time_t tv_sec; __syscall_slong_t tv_nsec; # 31 "/usr/include/riscv64-linux-gnu/bits/types/struct_timespec.h" 3 4 }; # 33 "/usr/include/sched.h" 2 3 4 typedef __pid_t pid_t; # 1 "/usr/include/riscv64-linux-gnu/bits/sched.h" 1 3 4 # 63 "/usr/include/riscv64-linux-gnu/bits/sched.h" 3 4 # 1 "/usr/include/linux/sched/types.h" 1 3 4 # 1 "/usr/include/linux/types.h" 1 3 4 # 1 "/usr/include/riscv64-linux-gnu/asm/types.h" 1 3 4 # 1 "/usr/include/asm-generic/types.h" 1 3 4 # 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4 # 12 "/usr/include/asm-generic/int-ll64.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/asm/bitsperlong.h" 1 3 4 # 12 "/usr/include/riscv64-linux-gnu/asm/bitsperlong.h" 3 4 # 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4 # 13 "/usr/include/riscv64-linux-gnu/asm/bitsperlong.h" 2 3 4 # 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4 typedef __signed__ char __s8; typedef unsigned char __u8; typedef __signed__ short __s16; typedef unsigned short __u16; typedef __signed__ int __s32; typedef unsigned int __u32; __extension__ typedef __signed__ long long __s64; __extension__ typedef unsigned long long __u64; # 8 "/usr/include/asm-generic/types.h" 2 3 4 # 2 "/usr/include/riscv64-linux-gnu/asm/types.h" 2 3 4 # 6 "/usr/include/linux/types.h" 2 3 4 # 1 "/usr/include/linux/posix_types.h" 1 3 4 # 1 "/usr/include/linux/stddef.h" 1 3 4 # 6 "/usr/include/linux/posix_types.h" 2 3 4 # 25 "/usr/include/linux/posix_types.h" 3 4 typedef struct { unsigned long fds_bits[1024 / (8 * sizeof(long))]; } __kernel_fd_set; typedef void (*__kernel_sighandler_t)(int); typedef int __kernel_key_t; typedef int __kernel_mqd_t; # 1 "/usr/include/riscv64-linux-gnu/asm/posix_types.h" 1 3 4 # 1 "/usr/include/asm-generic/posix_types.h" 1 3 4 # 15 "/usr/include/asm-generic/posix_types.h" 3 4 typedef long __kernel_long_t; typedef unsigned long __kernel_ulong_t; typedef __kernel_ulong_t __kernel_ino_t; typedef unsigned int __kernel_mode_t; typedef int __kernel_pid_t; typedef int __kernel_ipc_pid_t; typedef unsigned int __kernel_uid_t; typedef unsigned int __kernel_gid_t; typedef __kernel_long_t __kernel_suseconds_t; typedef int __kernel_daddr_t; typedef unsigned int __kernel_uid32_t; typedef unsigned int __kernel_gid32_t; typedef __kernel_uid_t __kernel_old_uid_t; typedef __kernel_gid_t __kernel_old_gid_t; typedef unsigned int __kernel_old_dev_t; # 72 "/usr/include/asm-generic/posix_types.h" 3 4 typedef __kernel_ulong_t __kernel_size_t; typedef __kernel_long_t __kernel_ssize_t; typedef __kernel_long_t __kernel_ptrdiff_t; typedef struct { int val[2]; } __kernel_fsid_t; typedef __kernel_long_t __kernel_off_t; typedef long long __kernel_loff_t; typedef __kernel_long_t __kernel_old_time_t; typedef __kernel_long_t __kernel_time_t; typedef long long __kernel_time64_t; typedef __kernel_long_t __kernel_clock_t; typedef int __kernel_timer_t; typedef int __kernel_clockid_t; typedef char * __kernel_caddr_t; typedef unsigned short __kernel_uid16_t; typedef unsigned short __kernel_gid16_t; # 2 "/usr/include/riscv64-linux-gnu/asm/posix_types.h" 2 3 4 # 37 "/usr/include/linux/posix_types.h" 2 3 4 # 10 "/usr/include/linux/types.h" 2 3 4 typedef __signed__ __int128 __s128 __attribute__((aligned(16))); typedef unsigned __int128 __u128 __attribute__((aligned(16))); # 31 "/usr/include/linux/types.h" 3 4 typedef __u16 __le16; typedef __u16 __be16; typedef __u32 __le32; typedef __u32 __be32; typedef __u64 __le64; typedef __u64 __be64; typedef __u16 __sum16; typedef __u32 __wsum; # 55 "/usr/include/linux/types.h" 3 4 typedef unsigned __poll_t; # 6 "/usr/include/linux/sched/types.h" 2 3 4 # 98 "/usr/include/linux/sched/types.h" 3 4 struct sched_attr { __u32 size; __u32 sched_policy; __u64 sched_flags; __s32 sched_nice; __u32 sched_priority; __u64 sched_runtime; __u64 sched_deadline; __u64 sched_period; __u32 sched_util_min; __u32 sched_util_max; }; # 64 "/usr/include/riscv64-linux-gnu/bits/sched.h" 2 3 4 # 126 "/usr/include/riscv64-linux-gnu/bits/sched.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_sched_param.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/types/struct_sched_param.h" 3 4 struct sched_param { int sched_priority; }; # 127 "/usr/include/riscv64-linux-gnu/bits/sched.h" 2 3 4 extern "C" { extern int clone (int (*__fn) (void *__arg), void *__child_stack, int __flags, void *__arg, ...) noexcept (true); extern int unshare (int __flags) noexcept (true); extern int sched_getcpu (void) noexcept (true); extern int getcpu (unsigned int *, unsigned int *) noexcept (true); extern int setns (int __fd, int __nstype) noexcept (true); int sched_setattr (pid_t tid, struct sched_attr *attr, unsigned int flags) noexcept (true) __attribute__ ((__nonnull__ (2))); int sched_getattr (pid_t tid, struct sched_attr *attr, unsigned int size, unsigned int flags) noexcept (true) __attribute__ ((__nonnull__ (2))); } # 44 "/usr/include/sched.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/cpu-set.h" 1 3 4 # 32 "/usr/include/riscv64-linux-gnu/bits/cpu-set.h" 3 4 typedef unsigned long int __cpu_mask; typedef struct { __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; } cpu_set_t; # 115 "/usr/include/riscv64-linux-gnu/bits/cpu-set.h" 3 4 extern "C" { extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) noexcept (true); extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) __attribute__ ((__warn_unused_result__)); extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); } # 45 "/usr/include/sched.h" 2 3 4 extern "C" { extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) noexcept (true); extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); extern int sched_setscheduler (__pid_t __pid, int __policy, const struct sched_param *__param) noexcept (true); extern int sched_getscheduler (__pid_t __pid) noexcept (true); extern int sched_yield (void) noexcept (true); extern int sched_get_priority_max (int __algorithm) noexcept (true); extern int sched_get_priority_min (int __algorithm) noexcept (true); extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); # 130 "/usr/include/sched.h" 3 4 extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, const cpu_set_t *__cpuset) noexcept (true); extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, cpu_set_t *__cpuset) noexcept (true); } # 23 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/time.h" 1 3 4 # 29 "/usr/include/time.h" 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 30 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/time.h" 1 3 4 # 73 "/usr/include/riscv64-linux-gnu/bits/time.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/timex.h" 1 3 4 # 22 "/usr/include/riscv64-linux-gnu/bits/timex.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_timeval.h" 1 3 4 struct timeval { __time_t tv_sec; __suseconds_t tv_usec; }; # 23 "/usr/include/riscv64-linux-gnu/bits/timex.h" 2 3 4 struct timex { # 58 "/usr/include/riscv64-linux-gnu/bits/timex.h" 3 4 unsigned int modes; __syscall_slong_t offset; __syscall_slong_t freq; __syscall_slong_t maxerror; __syscall_slong_t esterror; int status; __syscall_slong_t constant; __syscall_slong_t precision; __syscall_slong_t tolerance; struct timeval time; __syscall_slong_t tick; __syscall_slong_t ppsfreq; __syscall_slong_t jitter; int shift; __syscall_slong_t stabil; __syscall_slong_t jitcnt; __syscall_slong_t calcnt; __syscall_slong_t errcnt; __syscall_slong_t stbcnt; int tai; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; }; # 74 "/usr/include/riscv64-linux-gnu/bits/time.h" 2 3 4 extern "C" { extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); # 90 "/usr/include/riscv64-linux-gnu/bits/time.h" 3 4 } # 34 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/clock_t.h" 1 3 4 typedef __clock_t clock_t; # 38 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_tm.h" 1 3 4 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; long int tm_gmtoff; const char *tm_zone; }; # 40 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/clockid_t.h" 1 3 4 typedef __clockid_t clockid_t; # 47 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/timer_t.h" 1 3 4 typedef __timer_t timer_t; # 48 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4 struct itimerspec { struct timespec it_interval; struct timespec it_value; }; # 49 "/usr/include/time.h" 2 3 4 struct sigevent; # 68 "/usr/include/time.h" 3 4 extern "C" { extern clock_t clock (void) noexcept (true); extern time_t time (time_t *__timer) noexcept (true); extern double difftime (time_t __time1, time_t __time0); extern time_t mktime (struct tm *__tp) noexcept (true); # 99 "/usr/include/time.h" 3 4 extern size_t strftime (char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __tp) noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); extern char *strptime (const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp) noexcept (true); extern size_t strftime_l (char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __tp, locale_t __loc) noexcept (true); extern char *strptime_l (const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp, locale_t __loc) noexcept (true); extern struct tm *gmtime (const time_t *__timer) noexcept (true); extern struct tm *localtime (const time_t *__timer) noexcept (true); # 154 "/usr/include/time.h" 3 4 extern struct tm *gmtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp) noexcept (true); extern struct tm *localtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp) noexcept (true); # 179 "/usr/include/time.h" 3 4 extern char *asctime (const struct tm *__tp) noexcept (true); extern char *ctime (const time_t *__timer) noexcept (true); # 197 "/usr/include/time.h" 3 4 extern char *asctime_r (const struct tm *__restrict __tp, char *__restrict __buf) noexcept (true); extern char *ctime_r (const time_t *__restrict __timer, char *__restrict __buf) noexcept (true); # 217 "/usr/include/time.h" 3 4 extern char *__tzname[2]; extern int __daylight; extern long int __timezone; extern char *tzname[2]; extern void tzset (void) noexcept (true); extern int daylight; extern long int timezone; # 246 "/usr/include/time.h" 3 4 extern time_t timegm (struct tm *__tp) noexcept (true); # 263 "/usr/include/time.h" 3 4 extern time_t timelocal (struct tm *__tp) noexcept (true); extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); # 281 "/usr/include/time.h" 3 4 extern int nanosleep (const struct timespec *__requested_time, struct timespec *__remaining); extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) noexcept (true) __attribute__ ((__nonnull__ (2))); # 323 "/usr/include/time.h" 3 4 extern int clock_nanosleep (clockid_t __clock_id, int __flags, const struct timespec *__req, struct timespec *__rem); # 338 "/usr/include/time.h" 3 4 extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); extern int timer_create (clockid_t __clock_id, struct sigevent *__restrict __evp, timer_t *__restrict __timerid) noexcept (true); extern int timer_delete (timer_t __timerid) noexcept (true); extern int timer_settime (timer_t __timerid, int __flags, const struct itimerspec *__restrict __value, struct itimerspec *__restrict __ovalue) noexcept (true); extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) noexcept (true); # 376 "/usr/include/time.h" 3 4 extern int timer_getoverrun (timer_t __timerid) noexcept (true); extern int timespec_get (struct timespec *__ts, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); # 399 "/usr/include/time.h" 3 4 extern int timespec_getres (struct timespec *__ts, int __base) noexcept (true); # 425 "/usr/include/time.h" 3 4 extern int getdate_err; # 434 "/usr/include/time.h" 3 4 extern struct tm *getdate (const char *__string); # 448 "/usr/include/time.h" 3 4 extern int getdate_r (const char *__restrict __string, struct tm *__restrict __resbufp); } # 24 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/pthreadtypes.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/pthreadtypes.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 1 3 4 # 44 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4 # 45 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4 # 25 "/usr/include/riscv64-linux-gnu/bits/atomic_wide_counter.h" 3 4 typedef union { __extension__ unsigned long long int __value64; struct { unsigned int __low; unsigned int __high; } __value32; } __atomic_wide_counter; # 47 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 2 3 4 typedef struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __pthread_list_t; typedef struct __pthread_internal_slist { struct __pthread_internal_slist *__next; } __pthread_slist_t; # 76 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/struct_mutex.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/struct_mutex.h" 3 4 struct __pthread_mutex_s { int __lock ; unsigned int __count; int __owner; unsigned int __nusers; # 58 "/usr/include/riscv64-linux-gnu/bits/struct_mutex.h" 3 4 int __kind; int __spins; __pthread_list_t __list; # 74 "/usr/include/riscv64-linux-gnu/bits/struct_mutex.h" 3 4 }; # 77 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 2 3 4 # 89 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/struct_rwlock.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/struct_rwlock.h" 3 4 struct __pthread_rwlock_arch_t { unsigned int __readers; unsigned int __writers; unsigned int __wrphase_futex; unsigned int __writers_futex; unsigned int __pad3; unsigned int __pad4; int __cur_writer; int __shared; unsigned long int __pad1; unsigned long int __pad2; unsigned int __flags; # 55 "/usr/include/riscv64-linux-gnu/bits/struct_rwlock.h" 3 4 }; # 90 "/usr/include/riscv64-linux-gnu/bits/thread-shared-types.h" 2 3 4 struct __pthread_cond_s { __atomic_wide_counter __wseq; __atomic_wide_counter __g1_start; unsigned int __g_size[2] ; unsigned int __g1_orig_size; unsigned int __wrefs; unsigned int __g_signals[2]; unsigned int __unused_initialized_1; unsigned int __unused_initialized_2; }; typedef unsigned int __tss_t; typedef unsigned long int __thrd_t; typedef struct { int __data ; } __once_flag; # 24 "/usr/include/riscv64-linux-gnu/bits/pthreadtypes.h" 2 3 4 typedef unsigned long int pthread_t; typedef union { char __size[4]; int __align; } pthread_mutexattr_t; typedef union { char __size[4]; int __align; } pthread_condattr_t; typedef unsigned int pthread_key_t; typedef int pthread_once_t; union pthread_attr_t { char __size[56]; long int __align; }; typedef union pthread_attr_t pthread_attr_t; typedef union { struct __pthread_mutex_s __data; char __size[40]; long int __align; } pthread_mutex_t; typedef union { struct __pthread_cond_s __data; char __size[48]; __extension__ long long int __align; } pthread_cond_t; typedef union { struct __pthread_rwlock_arch_t __data; char __size[56]; long int __align; } pthread_rwlock_t; typedef union { char __size[8]; long int __align; } pthread_rwlockattr_t; typedef volatile int pthread_spinlock_t; typedef union { char __size[32]; long int __align; } pthread_barrier_t; typedef union { char __size[4]; int __align; } pthread_barrierattr_t; # 27 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/setjmp.h" 1 3 4 # 22 "/usr/include/riscv64-linux-gnu/bits/setjmp.h" 3 4 typedef struct __jmp_buf_internal_tag { long int __pc; long int __regs[12]; long int __sp; double __fpregs[12]; } __jmp_buf[1]; # 28 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 29 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/__sigset_t.h" 1 3 4 typedef struct { unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; } __sigset_t; # 31 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct___jmp_buf_tag.h" 1 3 4 # 26 "/usr/include/riscv64-linux-gnu/bits/types/struct___jmp_buf_tag.h" 3 4 struct __jmp_buf_tag { __jmp_buf __jmpbuf; int __mask_was_saved; __sigset_t __saved_mask; }; # 32 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/pthread_stack_min-dynamic.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 extern "C" { extern long int __sysconf (int __name) noexcept (true); } # 34 "/usr/include/pthread.h" 2 3 4 enum { PTHREAD_CREATE_JOINABLE, PTHREAD_CREATE_DETACHED }; enum { PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_ADAPTIVE_NP , PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP }; enum { PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_ROBUST, PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST }; enum { PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, PTHREAD_PRIO_PROTECT }; # 104 "/usr/include/pthread.h" 3 4 enum { PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP }; # 124 "/usr/include/pthread.h" 3 4 enum { PTHREAD_INHERIT_SCHED, PTHREAD_EXPLICIT_SCHED }; enum { PTHREAD_SCOPE_SYSTEM, PTHREAD_SCOPE_PROCESS }; enum { PTHREAD_PROCESS_PRIVATE, PTHREAD_PROCESS_SHARED }; # 159 "/usr/include/pthread.h" 3 4 struct _pthread_cleanup_buffer { void (*__routine) (void *); void *__arg; int __canceltype; struct _pthread_cleanup_buffer *__prev; }; enum { PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE }; enum { PTHREAD_CANCEL_DEFERRED, PTHREAD_CANCEL_ASYNCHRONOUS }; # 197 "/usr/include/pthread.h" 3 4 extern "C" { extern int pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t *__restrict __attr, void *(*__start_routine) (void *), void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); extern int pthread_join (pthread_t __th, void **__thread_return); extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); # 233 "/usr/include/pthread.h" 3 4 extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, const struct timespec *__abstime); # 243 "/usr/include/pthread.h" 3 4 extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, clockid_t __clockid, const struct timespec *__abstime); # 269 "/usr/include/pthread.h" 3 4 extern int pthread_detach (pthread_t __th) noexcept (true); extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) __attribute__ ((__const__)); extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_destroy (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, int *__detachstate) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, int __detachstate) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, size_t *__guardsize) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setguardsize (pthread_attr_t *__attr, size_t __guardsize) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, struct sched_param *__restrict __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, const struct sched_param *__restrict __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict __attr, int *__restrict __policy) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict __attr, int *__restrict __inherit) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, int __inherit) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, int *__restrict __scope) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr, void **__restrict __stackaddr) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, void *__stackaddr) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr, size_t *__restrict __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setstacksize (pthread_attr_t *__attr, size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, void **__restrict __stackaddr, size_t *__restrict __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, size_t __cpusetsize, const cpu_set_t *__cpuset) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, size_t __cpusetsize, cpu_set_t *__cpuset) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern int pthread_getattr_default_np (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, const __sigset_t *sigmask); extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, __sigset_t *sigmask); extern int pthread_setattr_default_np (const pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int pthread_setschedparam (pthread_t __target_thread, int __policy, const struct sched_param *__param) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int pthread_getschedparam (pthread_t __target_thread, int *__restrict __policy, struct sched_param *__restrict __param) noexcept (true) __attribute__ ((__nonnull__ (2, 3))); extern int pthread_setschedprio (pthread_t __target_thread, int __prio) noexcept (true); extern int pthread_getname_np (pthread_t __target_thread, char *__buf, size_t __buflen) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int pthread_setname_np (pthread_t __target_thread, const char *__name) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int pthread_getconcurrency (void) noexcept (true); extern int pthread_setconcurrency (int __level) noexcept (true); extern int pthread_yield (void) noexcept (true); extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))) ; extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, const cpu_set_t *__cpuset) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, cpu_set_t *__cpuset) noexcept (true) __attribute__ ((__nonnull__ (3))); # 509 "/usr/include/pthread.h" 3 4 extern int pthread_once (pthread_once_t *__once_control, void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); # 521 "/usr/include/pthread.h" 3 4 extern int pthread_setcancelstate (int __state, int *__oldstate); extern int pthread_setcanceltype (int __type, int *__oldtype); extern int pthread_cancel (pthread_t __th); extern void pthread_testcancel (void); struct __cancel_jmp_buf_tag { __jmp_buf __cancel_jmp_buf; int __mask_was_saved; }; typedef struct { struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; void *__pad[4]; } __pthread_unwind_buf_t __attribute__ ((__aligned__)); # 557 "/usr/include/pthread.h" 3 4 struct __pthread_cleanup_frame { void (*__cancel_routine) (void *); void *__cancel_arg; int __do_it; int __cancel_type; }; class __pthread_cleanup_class { void (*__cancel_routine) (void *); void *__cancel_arg; int __do_it; int __cancel_type; public: __pthread_cleanup_class (void (*__fct) (void *), void *__arg) : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } void __setdoit (int __newval) { __do_it = __newval; } void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &__cancel_type); } void __restore () const { pthread_setcanceltype (__cancel_type, 0); } }; # 766 "/usr/include/pthread.h" 3 4 extern int __sigsetjmp_cancel (struct __cancel_jmp_buf_tag __env[1], int __savemask) noexcept (true) __asm__ ("" "__sigsetjmp") __attribute__ ((__returns_twice__)); # 781 "/usr/include/pthread.h" 3 4 extern int pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_lock (pthread_mutex_t *__mutex) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, const struct timespec *__restrict __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); # 817 "/usr/include/pthread.h" 3 4 extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, clockid_t __clockid, const struct timespec *__restrict __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); # 835 "/usr/include/pthread.h" 3 4 extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_getprioceiling (const pthread_mutex_t * __restrict __mutex, int *__restrict __prioceiling) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, int __prioceiling, int *__restrict __old_ceiling) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))) ; # 874 "/usr/include/pthread.h" 3 4 extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * __restrict __attr, int *__restrict __pshared) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict __attr, int *__restrict __kind) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * __restrict __attr, int *__restrict __protocol) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, int __protocol) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * __restrict __attr, int *__restrict __prioceiling) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, int __prioceiling) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, int *__robustness) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))) ; extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, int __robustness) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))) ; # 967 "/usr/include/pthread.h" 3 4 extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, const pthread_rwlockattr_t *__restrict __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, const struct timespec *__restrict __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); # 1004 "/usr/include/pthread.h" 3 4 extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, clockid_t __clockid, const struct timespec *__restrict __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); # 1023 "/usr/include/pthread.h" 3 4 extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, const struct timespec *__restrict __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); # 1051 "/usr/include/pthread.h" 3 4 extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, clockid_t __clockid, const struct timespec *__restrict __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); # 1071 "/usr/include/pthread.h" 3 4 extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * __restrict __attr, int *__restrict __pshared) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * __restrict __attr, int *__restrict __pref) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_cond_init (pthread_cond_t *__restrict __cond, const pthread_condattr_t *__restrict __cond_attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_cond_destroy (pthread_cond_t *__cond) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_cond_signal (pthread_cond_t *__cond) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_cond_broadcast (pthread_cond_t *__cond) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex) __attribute__ ((__nonnull__ (1, 2))); # 1145 "/usr/include/pthread.h" 3 4 extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex, const struct timespec *__restrict __abstime) __attribute__ ((__nonnull__ (1, 2, 3))); # 1171 "/usr/include/pthread.h" 3 4 extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex, __clockid_t __clock_id, const struct timespec *__restrict __abstime) __attribute__ ((__nonnull__ (1, 2, 4))); # 1194 "/usr/include/pthread.h" 3 4 extern int pthread_condattr_init (pthread_condattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_condattr_destroy (pthread_condattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_condattr_getpshared (const pthread_condattr_t * __restrict __attr, int *__restrict __pshared) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_condattr_getclock (const pthread_condattr_t * __restrict __attr, __clockid_t *__restrict __clock_id) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_condattr_setclock (pthread_condattr_t *__attr, __clockid_t __clock_id) noexcept (true) __attribute__ ((__nonnull__ (1))); # 1230 "/usr/include/pthread.h" 3 4 extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_spin_destroy (pthread_spinlock_t *__lock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_spin_lock (pthread_spinlock_t *__lock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_spin_trylock (pthread_spinlock_t *__lock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_spin_unlock (pthread_spinlock_t *__lock) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, const pthread_barrierattr_t *__restrict __attr, unsigned int __count) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_barrier_wait (pthread_barrier_t *__barrier) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * __restrict __attr, int *__restrict __pshared) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); # 1297 "/usr/include/pthread.h" 3 4 extern int pthread_key_create (pthread_key_t *__key, void (*__destr_function) (void *)) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int pthread_key_delete (pthread_key_t __key) noexcept (true); extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); extern int pthread_setspecific (pthread_key_t __key, const void *__pointer) noexcept (true) __attribute__ ((__access__ (__none__, 2))); extern int pthread_getcpuclockid (pthread_t __thread_id, __clockid_t *__clock_id) noexcept (true) __attribute__ ((__nonnull__ (2))); extern pid_t pthread_gettid_np (pthread_t __thread_id); # 1337 "/usr/include/pthread.h" 3 4 extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void), void (*__child) (void)) noexcept (true); extern __inline __attribute__ ((__gnu_inline__)) int __attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) { return __thread1 == __thread2; } } # 36 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 2 3 # 62 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 typedef pthread_t __gthread_t; typedef pthread_key_t __gthread_key_t; typedef pthread_once_t __gthread_once_t; typedef pthread_mutex_t __gthread_mutex_t; typedef pthread_mutex_t __gthread_recursive_mutex_t; typedef pthread_cond_t __gthread_cond_t; typedef struct timespec __gthread_time_t; # 123 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 # 345 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 inline __attribute__((__always_inline__)) int __gthread_active_p (void) { return 1; } # 705 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 inline __attribute__((__always_inline__)) int __gthread_create (__gthread_t *__threadid, void *(*__func) (void*), void *__args) { return pthread_create (__threadid, __null, __func, __args); } inline __attribute__((__always_inline__)) int __gthread_join (__gthread_t __threadid, void **__value_ptr) { return pthread_join (__threadid, __value_ptr); } inline __attribute__((__always_inline__)) int __gthread_detach (__gthread_t __threadid) { return pthread_detach (__threadid); } inline __attribute__((__always_inline__)) int __gthread_equal (__gthread_t __t1, __gthread_t __t2) { return pthread_equal (__t1, __t2); } inline __attribute__((__always_inline__)) __gthread_t __gthread_self (void) { return pthread_self (); } inline __attribute__((__always_inline__)) int __gthread_yield (void) { return sched_yield (); } inline __attribute__((__always_inline__)) int __gthread_once (__gthread_once_t *__once, void (*__func) (void)) { if (__gthread_active_p ()) return pthread_once (__once, __func); else return -1; } inline __attribute__((__always_inline__)) int __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) { return pthread_key_create (__key, __dtor); } inline __attribute__((__always_inline__)) int __gthread_key_delete (__gthread_key_t __key) { return pthread_key_delete (__key); } inline __attribute__((__always_inline__)) void * __gthread_getspecific (__gthread_key_t __key) { return pthread_getspecific (__key); } inline __attribute__((__always_inline__)) int __gthread_setspecific (__gthread_key_t __key, const void *__ptr) { return pthread_setspecific (__key, __ptr); } inline __attribute__((__always_inline__)) void __gthread_mutex_init_function (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) pthread_mutex_init (__mutex, __null); } inline __attribute__((__always_inline__)) int __gthread_mutex_destroy (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return pthread_mutex_destroy (__mutex); else return 0; } inline __attribute__((__always_inline__)) int __gthread_mutex_lock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return pthread_mutex_lock (__mutex); else return 0; } inline __attribute__((__always_inline__)) int __gthread_mutex_trylock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return pthread_mutex_trylock (__mutex); else return 0; } inline __attribute__((__always_inline__)) int __gthread_mutex_timedlock (__gthread_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { if (__gthread_active_p ()) return pthread_mutex_timedlock (__mutex, __abs_timeout); else return 0; } inline __attribute__((__always_inline__)) int __gthread_mutex_unlock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return pthread_mutex_unlock (__mutex); else return 0; } # 854 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 inline __attribute__((__always_inline__)) int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_lock (__mutex); } inline __attribute__((__always_inline__)) int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_trylock (__mutex); } inline __attribute__((__always_inline__)) int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { return __gthread_mutex_timedlock (__mutex, __abs_timeout); } inline __attribute__((__always_inline__)) int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_unlock (__mutex); } inline __attribute__((__always_inline__)) int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_destroy (__mutex); } # 896 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr-default.h" 3 inline __attribute__((__always_inline__)) int __gthread_cond_broadcast (__gthread_cond_t *__cond) { return pthread_cond_broadcast (__cond); } inline __attribute__((__always_inline__)) int __gthread_cond_signal (__gthread_cond_t *__cond) { return pthread_cond_signal (__cond); } inline __attribute__((__always_inline__)) int __gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) { return pthread_cond_wait (__cond, __mutex); } inline __attribute__((__always_inline__)) int __gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); } inline __attribute__((__always_inline__)) int __gthread_cond_wait_recursive (__gthread_cond_t *__cond, __gthread_recursive_mutex_t *__mutex) { return __gthread_cond_wait (__cond, __mutex); } inline __attribute__((__always_inline__)) int __gthread_cond_destroy (__gthread_cond_t* __cond) { return pthread_cond_destroy (__cond); } # 158 "/usr/include/riscv64-linux-gnu/c++/15/bits/gthr.h" 2 3 #pragma GCC visibility pop # 38 "/usr/include/c++/15/ext/atomicity.h" 2 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/atomic_word.h" 1 3 # 32 "/usr/include/riscv64-linux-gnu/c++/15/bits/atomic_word.h" 3 typedef int _Atomic_word; # 39 "/usr/include/c++/15/ext/atomicity.h" 2 3 # 1 "/usr/include/riscv64-linux-gnu/sys/single_threaded.h" 1 3 4 # 24 "/usr/include/riscv64-linux-gnu/sys/single_threaded.h" 3 4 extern "C" { extern char __libc_single_threaded; } # 41 "/usr/include/c++/15/ext/atomicity.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { __attribute__((__always_inline__)) inline bool __is_single_threaded() noexcept { return ::__libc_single_threaded; } inline _Atomic_word __attribute__((__always_inline__)) __exchange_and_add(volatile _Atomic_word* __mem, int __val) { return __atomic_fetch_add(__mem, __val, 4); } inline void __attribute__((__always_inline__)) __atomic_add(volatile _Atomic_word* __mem, int __val) { __atomic_fetch_add(__mem, __val, 4); } # 82 "/usr/include/c++/15/ext/atomicity.h" 3 inline _Atomic_word __attribute__((__always_inline__)) __exchange_and_add_single(_Atomic_word* __mem, int __val) { _Atomic_word __result = *__mem; *__mem += __val; return __result; } inline void __attribute__((__always_inline__)) __atomic_add_single(_Atomic_word* __mem, int __val) { *__mem += __val; } inline _Atomic_word __attribute__ ((__always_inline__)) __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) { if (__is_single_threaded()) return __exchange_and_add_single(__mem, __val); else return __exchange_and_add(__mem, __val); } inline void __attribute__ ((__always_inline__)) __atomic_add_dispatch(_Atomic_word* __mem, int __val) { if (__is_single_threaded()) __atomic_add_single(__mem, __val); else __atomic_add(__mem, __val); } } # 42 "/usr/include/c++/15/bits/ios_base.h" 2 3 # 1 "/usr/include/c++/15/bits/locale_classes.h" 1 3 # 42 "/usr/include/c++/15/bits/locale_classes.h" 3 # 1 "/usr/include/c++/15/string" 1 3 # 48 "/usr/include/c++/15/string" 3 # 1 "/usr/include/c++/15/bits/ostream_insert.h" 1 3 # 38 "/usr/include/c++/15/bits/ostream_insert.h" 3 # 1 "/usr/include/c++/15/bits/cxxabi_forced.h" 1 3 # 38 "/usr/include/c++/15/bits/cxxabi_forced.h" 3 #pragma GCC visibility push(default) namespace __cxxabiv1 { class __forced_unwind { virtual ~__forced_unwind() throw(); virtual void __pure_dummy() = 0; }; } #pragma GCC visibility pop # 39 "/usr/include/c++/15/bits/ostream_insert.h" 2 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template inline void __ostream_write(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const streamsize __put = __out.rdbuf()->sputn(__s, __n); if (__put != __n) __out.setstate(__ios_base::badbit); } template inline void __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const _CharT __c = __out.fill(); for (; __n > 0; --__n) { const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); if (_Traits::eq_int_type(__put, _Traits::eof())) { __out.setstate(__ios_base::badbit); break; } } } template basic_ostream<_CharT, _Traits>& __ostream_insert(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; typename __ostream_type::sentry __cerb(__out); if (__cerb) { try { const streamsize __w = __out.width(); if (__w > __n) { const bool __left = ((__out.flags() & __ios_base::adjustfield) == __ios_base::left); if (!__left) __ostream_fill(__out, __w - __n); if (__out.good()) __ostream_write(__out, __s, __n); if (__left && __out.good()) __ostream_fill(__out, __w - __n); } else __ostream_write(__out, __s, __n); __out.width(0); } catch(__cxxabiv1::__forced_unwind&) { __out._M_setstate(__ios_base::badbit); throw; } catch(...) { __out._M_setstate(__ios_base::badbit); } } return __out; } extern template ostream& __ostream_insert(ostream&, const char*, streamsize); extern template wostream& __ostream_insert(wostream&, const wchar_t*, streamsize); } #pragma GCC diagnostic pop # 49 "/usr/include/c++/15/string" 2 3 # 1 "/usr/include/c++/15/bits/basic_string.h" 1 3 # 48 "/usr/include/c++/15/bits/basic_string.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 49 "/usr/include/c++/15/bits/basic_string.h" 2 3 # 1 "/usr/include/c++/15/string_view" 1 3 # 46 "/usr/include/c++/15/string_view" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 47 "/usr/include/c++/15/string_view" 2 3 # 66 "/usr/include/c++/15/string_view" 3 namespace std __attribute__ ((__visibility__ ("default"))) { constexpr size_t __sv_check(size_t __size, size_t __pos, const char* __s) { if (__pos > __size) __throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is %zu)") , __s, __pos, __size); return __pos; } constexpr size_t __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept { const bool __testoff = __off < __size - __pos; return __testoff ? __off : __size - __pos; } # 107 "/usr/include/c++/15/string_view" 3 template> class basic_string_view { static_assert(!is_array_v<_CharT>); static_assert(is_trivially_copyable_v<_CharT> && is_trivially_default_constructible_v<_CharT> && is_standard_layout_v<_CharT>); static_assert(is_same_v<_CharT, typename _Traits::char_type>); public: using traits_type = _Traits; using value_type = _CharT; using pointer = value_type*; using const_pointer = const value_type*; using reference = value_type&; using const_reference = const value_type&; using const_iterator = const value_type*; using iterator = const_iterator; using const_reverse_iterator = std::reverse_iterator; using reverse_iterator = const_reverse_iterator; using size_type = size_t; using difference_type = ptrdiff_t; static constexpr size_type npos = size_type(-1); constexpr basic_string_view() noexcept : _M_len{0}, _M_str{nullptr} { } constexpr basic_string_view(const basic_string_view&) noexcept = default; [[__gnu__::__nonnull__]] constexpr basic_string_view(const _CharT* __str) noexcept : _M_len{traits_type::length(__str)}, _M_str{__str} { } constexpr basic_string_view(const _CharT* __str, size_type __len) noexcept : _M_len{__len}, _M_str{__str} { } # 184 "/usr/include/c++/15/string_view" 3 constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default; [[nodiscard]] constexpr const_iterator begin() const noexcept { return this->_M_str; } [[nodiscard]] constexpr const_iterator end() const noexcept { return this->_M_str + this->_M_len; } [[nodiscard]] constexpr const_iterator cbegin() const noexcept { return this->_M_str; } [[nodiscard]] constexpr const_iterator cend() const noexcept { return this->_M_str + this->_M_len; } [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(this->end()); } [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator(this->begin()); } [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); } [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); } [[nodiscard]] constexpr size_type size() const noexcept { return this->_M_len; } [[nodiscard]] constexpr size_type length() const noexcept { return _M_len; } [[nodiscard]] constexpr size_type max_size() const noexcept { return (npos - sizeof(size_type) - sizeof(void*)) / sizeof(value_type) / 4; } [[nodiscard]] constexpr bool empty() const noexcept { return this->_M_len == 0; } [[nodiscard]] constexpr const_reference operator[](size_type __pos) const noexcept { do { if (std::__is_constant_evaluated() && !bool(__pos < this->_M_len)) std::__glibcxx_assert_fail(); } while (false); return *(this->_M_str + __pos); } [[nodiscard]] constexpr const_reference at(size_type __pos) const { if (__pos >= _M_len) __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)") , __pos, this->size()); return *(this->_M_str + __pos); } [[nodiscard]] constexpr const_reference front() const noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) std::__glibcxx_assert_fail(); } while (false); return *this->_M_str; } [[nodiscard]] constexpr const_reference back() const noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) std::__glibcxx_assert_fail(); } while (false); return *(this->_M_str + this->_M_len - 1); } [[nodiscard]] constexpr const_pointer data() const noexcept { return this->_M_str; } constexpr void remove_prefix(size_type __n) noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_len >= __n)) std::__glibcxx_assert_fail(); } while (false); this->_M_str += __n; this->_M_len -= __n; } constexpr void remove_suffix(size_type __n) noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_len >= __n)) std::__glibcxx_assert_fail(); } while (false); this->_M_len -= __n; } constexpr void swap(basic_string_view& __sv) noexcept { auto __tmp = *this; *this = __sv; __sv = __tmp; } size_type copy(_CharT* __str, size_type __n, size_type __pos = 0) const { ; __pos = std::__sv_check(size(), __pos, "basic_string_view::copy"); const size_type __rlen = std::min(__n, _M_len - __pos); traits_type::copy(__str, data() + __pos, __rlen); return __rlen; } [[nodiscard]] constexpr basic_string_view substr(size_type __pos = 0, size_type __n = npos) const noexcept(false) { __pos = std::__sv_check(size(), __pos, "basic_string_view::substr"); const size_type __rlen = std::min(__n, _M_len - __pos); return basic_string_view{_M_str + __pos, __rlen}; } [[nodiscard]] constexpr int compare(basic_string_view __str) const noexcept { const size_type __rlen = std::min(this->_M_len, __str._M_len); int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen); if (__ret == 0) __ret = _S_compare(this->_M_len, __str._M_len); return __ret; } [[nodiscard]] constexpr int compare(size_type __pos1, size_type __n1, basic_string_view __str) const { return this->substr(__pos1, __n1).compare(__str); } [[nodiscard]] constexpr int compare(size_type __pos1, size_type __n1, basic_string_view __str, size_type __pos2, size_type __n2) const { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); } [[nodiscard, __gnu__::__nonnull__]] constexpr int compare(const _CharT* __str) const noexcept { return this->compare(basic_string_view{__str}); } [[nodiscard, __gnu__::__nonnull__]] constexpr int compare(size_type __pos1, size_type __n1, const _CharT* __str) const { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } [[nodiscard]] constexpr int compare(size_type __pos1, size_type __n1, const _CharT* __str, size_type __n2) const noexcept(false) { return this->substr(__pos1, __n1) .compare(basic_string_view(__str, __n2)); } # 452 "/usr/include/c++/15/string_view" 3 [[nodiscard]] constexpr size_type find(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find(__str._M_str, __pos, __str._M_len); } [[nodiscard]] constexpr size_type find(_CharT __c, size_type __pos = 0) const noexcept; [[nodiscard]] constexpr size_type find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; [[nodiscard, __gnu__::__nonnull__]] constexpr size_type find(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find(__str, __pos, traits_type::length(__str)); } [[nodiscard]] constexpr size_type rfind(basic_string_view __str, size_type __pos = npos) const noexcept { return this->rfind(__str._M_str, __pos, __str._M_len); } [[nodiscard]] constexpr size_type rfind(_CharT __c, size_type __pos = npos) const noexcept; [[nodiscard]] constexpr size_type rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; [[nodiscard, __gnu__::__nonnull__]] constexpr size_type rfind(const _CharT* __str, size_type __pos = npos) const noexcept { return this->rfind(__str, __pos, traits_type::length(__str)); } [[nodiscard]] constexpr size_type find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str._M_str, __pos, __str._M_len); } [[nodiscard]] constexpr size_type find_first_of(_CharT __c, size_type __pos = 0) const noexcept { return this->find(__c, __pos); } [[nodiscard]] constexpr size_type find_first_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; [[nodiscard, __gnu__::__nonnull__]] constexpr size_type find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str, __pos, traits_type::length(__str)); } [[nodiscard]] constexpr size_type find_last_of(basic_string_view __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str._M_str, __pos, __str._M_len); } [[nodiscard]] constexpr size_type find_last_of(_CharT __c, size_type __pos=npos) const noexcept { return this->rfind(__c, __pos); } [[nodiscard]] constexpr size_type find_last_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; [[nodiscard, __gnu__::__nonnull__]] constexpr size_type find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str, __pos, traits_type::length(__str)); } [[nodiscard]] constexpr size_type find_first_not_of(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } [[nodiscard]] constexpr size_type find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; [[nodiscard]] constexpr size_type find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; [[nodiscard, __gnu__::__nonnull__]] constexpr size_type find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str, __pos, traits_type::length(__str)); } [[nodiscard]] constexpr size_type find_last_not_of(basic_string_view __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } [[nodiscard]] constexpr size_type find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; [[nodiscard]] constexpr size_type find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; [[nodiscard, __gnu__::__nonnull__]] constexpr size_type find_last_not_of(const _CharT* __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str, __pos, traits_type::length(__str)); } private: static constexpr int _S_compare(size_type __n1, size_type __n2) noexcept { using __limits = __gnu_cxx::__int_traits; const difference_type __diff = __n1 - __n2; if (__diff > __limits::__max) return __limits::__max; if (__diff < __limits::__min) return __limits::__min; return static_cast(__diff); } size_t _M_len; const _CharT* _M_str; }; # 630 "/usr/include/c++/15/string_view" 3 template [[nodiscard]] constexpr bool operator==(basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template [[nodiscard]] constexpr bool operator==(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template [[nodiscard]] constexpr bool operator==(__type_identity_t> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template [[nodiscard]] constexpr bool operator!=(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return !(__x == __y); } template [[nodiscard]] constexpr bool operator!=(basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return !(__x == __y); } template [[nodiscard]] constexpr bool operator!=(__type_identity_t> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return !(__x == __y); } template [[nodiscard]] constexpr bool operator< (basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) < 0; } template [[nodiscard]] constexpr bool operator< (basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return __x.compare(__y) < 0; } template [[nodiscard]] constexpr bool operator< (__type_identity_t> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) < 0; } template [[nodiscard]] constexpr bool operator> (basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) > 0; } template [[nodiscard]] constexpr bool operator> (basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return __x.compare(__y) > 0; } template [[nodiscard]] constexpr bool operator> (__type_identity_t> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) > 0; } template [[nodiscard]] constexpr bool operator<=(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) <= 0; } template [[nodiscard]] constexpr bool operator<=(basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return __x.compare(__y) <= 0; } template [[nodiscard]] constexpr bool operator<=(__type_identity_t> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) <= 0; } template [[nodiscard]] constexpr bool operator>=(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) >= 0; } template [[nodiscard]] constexpr bool operator>=(basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return __x.compare(__y) >= 0; } template [[nodiscard]] constexpr bool operator>=(__type_identity_t> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.compare(__y) >= 0; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT,_Traits> __str) { return __ostream_insert(__os, __str.data(), __str.size()); } using string_view = basic_string_view; using wstring_view = basic_string_view; using u16string_view = basic_string_view; using u32string_view = basic_string_view; template struct hash; template<> struct hash : public __hash_base { [[nodiscard]] size_t operator()(const string_view& __str) const noexcept { return std::_Hash_impl::hash(__str.data(), __str.length()); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { [[nodiscard]] size_t operator()(const wstring_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; # 832 "/usr/include/c++/15/string_view" 3 template<> struct hash : public __hash_base { [[nodiscard]] size_t operator()(const u16string_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char16_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { [[nodiscard]] size_t operator()(const u32string_view& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char32_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; inline namespace literals { inline namespace string_view_literals { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wliteral-suffix" inline constexpr basic_string_view operator""sv(const char* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const wchar_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const char16_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const char32_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } #pragma GCC diagnostic pop } } # 908 "/usr/include/c++/15/string_view" 3 } # 1 "/usr/include/c++/15/bits/string_view.tcc" 1 3 # 43 "/usr/include/c++/15/bits/string_view.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; if (__n == 0) return __pos <= _M_len ? __pos : npos; if (__pos >= _M_len) return npos; const _CharT __elem0 = __str[0]; const _CharT* __first = _M_str + __pos; const _CharT* const __last = _M_str + _M_len; size_type __len = _M_len - __pos; while (__len >= __n) { __first = traits_type::find(__first, __len - __n + 1, __elem0); if (!__first) return npos; if (traits_type::compare(__first, __str, __n) == 0) return __first - _M_str; __len = __last - ++__first; } return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find(_CharT __c, size_type __pos) const noexcept { size_type __ret = npos; if (__pos < this->_M_len) { const size_type __n = this->_M_len - __pos; const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c); if (__p) __ret = __p - this->_M_str; } return __ret; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; if (__n <= this->_M_len) { __pos = std::min(size_type(this->_M_len - __n), __pos); do { if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0) return __pos; } while (__pos-- > 0); } return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: rfind(_CharT __c, size_type __pos) const noexcept { size_type __size = this->_M_len; if (__size > 0) { if (--__size > __pos) __size = __pos; for (++__size; __size-- > 0; ) if (traits_type::eq(this->_M_str[__size], __c)) return __size; } return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find_first_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; for (; __n && __pos < this->_M_len; ++__pos) { const _CharT* __p = traits_type::find(__str, __n, this->_M_str[__pos]); if (__p) return __pos; } return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find_last_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; size_type __size = this->size(); if (__size && __n) { if (--__size > __pos) __size = __pos; do { if (traits_type::find(__str, __n, this->_M_str[__size])) return __size; } while (__size-- != 0); } return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; for (; __pos < this->_M_len; ++__pos) if (!traits_type::find(__str, __n, this->_M_str[__pos])) return __pos; return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find_first_not_of(_CharT __c, size_type __pos) const noexcept { for (; __pos < this->_M_len; ++__pos) if (!traits_type::eq(this->_M_str[__pos], __c)) return __pos; return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; size_type __size = this->_M_len; if (__size) { if (--__size > __pos) __size = __pos; do { if (!traits_type::find(__str, __n, this->_M_str[__size])) return __size; } while (__size--); } return npos; } template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find_last_not_of(_CharT __c, size_type __pos) const noexcept { size_type __size = this->_M_len; if (__size) { if (--__size > __pos) __size = __pos; do { if (!traits_type::eq(this->_M_str[__size], __c)) return __size; } while (__size--); } return npos; } } # 912 "/usr/include/c++/15/string_view" 2 3 # 52 "/usr/include/c++/15/bits/basic_string.h" 2 3 # 68 "/usr/include/c++/15/bits/basic_string.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { # 93 "/usr/include/c++/15/bits/basic_string.h" 3 template class basic_string { # 104 "/usr/include/c++/15/bits/basic_string.h" 3 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_CharT>::other _Char_alloc_type; typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; public: typedef _Traits traits_type; typedef typename _Traits::char_type value_type; typedef _Char_alloc_type allocator_type; typedef typename _Alloc_traits::size_type size_type; typedef typename _Alloc_traits::difference_type difference_type; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef __gnu_cxx::__normal_iterator iterator; typedef __gnu_cxx::__normal_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; static const size_type npos = static_cast(-1); protected: typedef const_iterator __const_iterator; private: static pointer _S_allocate(_Char_alloc_type& __a, size_type __n) { pointer __p = _Alloc_traits::allocate(__a, __n); # 152 "/usr/include/c++/15/bits/basic_string.h" 3 return __p; } typedef basic_string_view<_CharT, _Traits> __sv_type; template using _If_sv = enable_if_t< __and_, __not_>, __not_>>::value, _Res>; static __sv_type _S_to_string_view(__sv_type __svt) noexcept { return __svt; } struct __sv_wrapper { explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { } __sv_type _M_sv; }; explicit basic_string(__sv_wrapper __svw, const _Alloc& __a) : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { } struct _Alloc_hider : allocator_type { _Alloc_hider(pointer __dat, const _Alloc& __a) : allocator_type(__a), _M_p(__dat) { } _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc()) : allocator_type(std::move(__a)), _M_p(__dat) { } pointer _M_p; }; _Alloc_hider _M_dataplus; size_type _M_string_length; enum { _S_local_capacity = 15 / sizeof(_CharT) }; union { _CharT _M_local_buf[_S_local_capacity + 1]; size_type _M_allocated_capacity; }; void _M_data(pointer __p) { _M_dataplus._M_p = __p; } void _M_length(size_type __length) { _M_string_length = __length; } pointer _M_data() const { return _M_dataplus._M_p; } pointer _M_local_data() { return std::pointer_traits::pointer_to(*_M_local_buf); } const_pointer _M_local_data() const { return std::pointer_traits::pointer_to(*_M_local_buf); } void _M_capacity(size_type __capacity) { _M_allocated_capacity = __capacity; } void _M_set_length(size_type __n) { _M_length(__n); traits_type::assign(_M_data()[__n], _CharT()); } bool _M_is_local() const { if (_M_data() == _M_local_data()) { if (_M_string_length > _S_local_capacity) __builtin_unreachable(); return true; } return false; } pointer _M_create(size_type&, size_type); void _M_dispose() { if (!_M_is_local()) _M_destroy(_M_allocated_capacity); } void _M_destroy(size_type __size) throw() { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); } # 332 "/usr/include/c++/15/bits/basic_string.h" 3 template void _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag); template void _M_construct(_FwdIterator __beg, _FwdIterator __end, std::forward_iterator_tag); void _M_construct(size_type __req, _CharT __c); template void _M_construct(const _CharT *__c, size_type __n); allocator_type& _M_get_allocator() { return _M_dataplus; } const allocator_type& _M_get_allocator() const { return _M_dataplus; } __attribute__((__always_inline__)) constexpr void _M_init_local_buf() noexcept { } __attribute__((__always_inline__)) constexpr pointer _M_use_local_data() noexcept { return _M_local_data(); } private: # 407 "/usr/include/c++/15/bits/basic_string.h" 3 size_type _M_check(size_type __pos, const char* __s) const { if (__pos > this->size()) __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)") , __s, __pos, this->size()); return __pos; } void _M_check_length(size_type __n1, size_type __n2, const char* __s) const { if (this->max_size() - (this->size() - __n1) < __n2) __throw_length_error((__s)); } size_type _M_limit(size_type __pos, size_type __off) const noexcept { const bool __testoff = __off < this->size() - __pos; return __testoff ? __off : this->size() - __pos; } bool _M_disjunct(const _CharT* __s) const noexcept { return (less()(__s, _M_data()) || less()(_M_data() + this->size(), __s)); } static void _S_copy(_CharT* __d, const _CharT* __s, size_type __n) { if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::copy(__d, __s, __n); } static void _S_move(_CharT* __d, const _CharT* __s, size_type __n) { if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::move(__d, __s, __n); } static void _S_assign(_CharT* __d, size_type __n, _CharT __c) { if (__n == 1) traits_type::assign(*__d, __c); else traits_type::assign(__d, __n, __c); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template static void _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) { using _IterBase = decltype(std::__niter_base(__k1)); if constexpr (__or_, is_same<_IterBase, const _CharT*>>::value) _S_copy(__p, std::__niter_base(__k1), __k2 - __k1); # 502 "/usr/include/c++/15/bits/basic_string.h" 3 else for (; __k1 != __k2; ++__k1, (void)++__p) traits_type::assign(*__p, static_cast<_CharT>(*__k1)); } #pragma GCC diagnostic pop # 549 "/usr/include/c++/15/bits/basic_string.h" 3 static int _S_compare(size_type __n1, size_type __n2) noexcept { const difference_type __d = difference_type(__n1 - __n2); if (__d > __gnu_cxx::__numeric_traits::__max) return __gnu_cxx::__numeric_traits::__max; else if (__d < __gnu_cxx::__numeric_traits::__min) return __gnu_cxx::__numeric_traits::__min; else return int(__d); } void _M_assign(const basic_string&); void _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, size_type __len2); void _M_erase(size_type __pos, size_type __n); public: basic_string() noexcept(is_nothrow_default_constructible<_Alloc>::value) : _M_dataplus(_M_local_data()) { _M_init_local_buf(); _M_set_length(0); } explicit basic_string(const _Alloc& __a) noexcept : _M_dataplus(_M_local_data(), __a) { _M_init_local_buf(); _M_set_length(0); } basic_string(const basic_string& __str) : _M_dataplus(_M_local_data(), _Alloc_traits::_S_select_on_copy(__str._M_get_allocator())) { _M_construct(__str._M_data(), __str.length()); } # 628 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string(const basic_string& __str, size_type __pos, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { const _CharT* __start = __str._M_data() + __str._M_check(__pos, "basic_string::basic_string"); _M_construct(__start, __start + __str._M_limit(__pos, npos), std::forward_iterator_tag()); } basic_string(const basic_string& __str, size_type __pos, size_type __n) : _M_dataplus(_M_local_data()) { const _CharT* __start = __str._M_data() + __str._M_check(__pos, "basic_string::basic_string"); _M_construct(__start, __start + __str._M_limit(__pos, __n), std::forward_iterator_tag()); } # 663 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string(const basic_string& __str, size_type __pos, size_type __n, const _Alloc& __a) : _M_dataplus(_M_local_data(), __a) { const _CharT* __start = __str._M_data() + __str._M_check(__pos, "string::string"); _M_construct(__start, __start + __str._M_limit(__pos, __n), std::forward_iterator_tag()); } # 683 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string(const _CharT* __s, size_type __n, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { if (__s == 0 && __n > 0) std::__throw_logic_error(("basic_string: " "construction from null is not valid") ); _M_construct(__s, __s + __n, std::forward_iterator_tag()); } # 703 "/usr/include/c++/15/bits/basic_string.h" 3 template> basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { if (__s == 0) std::__throw_logic_error(("basic_string: " "construction from null is not valid") ); const _CharT* __end = __s + traits_type::length(__s); _M_construct(__s, __end, forward_iterator_tag()); } # 726 "/usr/include/c++/15/bits/basic_string.h" 3 template> basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__n, __c); } # 741 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string(basic_string&& __str) noexcept : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator())) { if (__str._M_is_local()) { _M_init_local_buf(); traits_type::copy(_M_local_buf, __str._M_local_buf, __str.length() + 1); } else { _M_data(__str._M_data()); _M_capacity(__str._M_allocated_capacity); } _M_length(__str.length()); __str._M_data(__str._M_use_local_data()); __str._M_set_length(0); } # 797 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); } basic_string(const basic_string& __str, const _Alloc& __a) : _M_dataplus(_M_local_data(), __a) { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); } basic_string(basic_string&& __str, const _Alloc& __a) noexcept(_Alloc_traits::_S_always_equal()) : _M_dataplus(_M_local_data(), __a) { if (__str._M_is_local()) { _M_init_local_buf(); traits_type::copy(_M_local_buf, __str._M_local_buf, __str.length() + 1); _M_length(__str.length()); __str._M_set_length(0); } else if (_Alloc_traits::_S_always_equal() || __str.get_allocator() == __a) { _M_data(__str._M_data()); _M_length(__str.length()); _M_capacity(__str._M_allocated_capacity); __str._M_data(__str._M_use_local_data()); __str._M_set_length(0); } else _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); } # 846 "/usr/include/c++/15/bits/basic_string.h" 3 template> basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a), _M_string_length(0) { _M_construct(__beg, __end, std::__iterator_category(__beg)); } # 872 "/usr/include/c++/15/bits/basic_string.h" 3 template>> basic_string(const _Tp& __t, size_type __pos, size_type __n, const _Alloc& __a = _Alloc()) : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { } template> explicit basic_string(const _Tp& __t, const _Alloc& __a = _Alloc()) : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { } ~basic_string() { _M_dispose(); } basic_string& operator=(const basic_string& __str) { return this->assign(__str); } basic_string& operator=(const _CharT* __s) { return this->assign(__s); } # 925 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& operator=(_CharT __c) { this->assign(1, __c); return *this; } # 943 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& operator=(basic_string&& __str) noexcept(_Alloc_traits::_S_nothrow_move()) { const bool __equal_allocs = _Alloc_traits::_S_always_equal() || _M_get_allocator() == __str._M_get_allocator(); if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign() && !__equal_allocs) { _M_destroy(_M_allocated_capacity); _M_data(_M_local_data()); _M_set_length(0); } std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator()); if (__str._M_is_local()) { if (__builtin_expect(std::__addressof(__str) != this, true)) { if (__str.size()) this->_S_copy(_M_data(), __str._M_data(), __str.size()); _M_set_length(__str.size()); } } else if (_Alloc_traits::_S_propagate_on_move_assign() || __equal_allocs) { pointer __data = nullptr; size_type __capacity; if (!_M_is_local()) { if (__equal_allocs) { __data = _M_data(); __capacity = _M_allocated_capacity; } else _M_destroy(_M_allocated_capacity); } _M_data(__str._M_data()); _M_length(__str.length()); _M_capacity(__str._M_allocated_capacity); if (__data) { __str._M_data(__data); __str._M_capacity(__capacity); } else __str._M_data(__str._M_use_local_data()); } else _M_assign(__str); __str.clear(); return *this; } basic_string& operator=(initializer_list<_CharT> __l) { this->assign(__l.begin(), __l.size()); return *this; } template _If_sv<_Tp, basic_string&> operator=(const _Tp& __svt) { return this->assign(__svt); } operator __sv_type() const noexcept { return __sv_type(data(), size()); } [[__nodiscard__]] iterator begin() noexcept { return iterator(_M_data()); } [[__nodiscard__]] const_iterator begin() const noexcept { return const_iterator(_M_data()); } [[__nodiscard__]] iterator end() noexcept { return iterator(_M_data() + this->size()); } [[__nodiscard__]] const_iterator end() const noexcept { return const_iterator(_M_data() + this->size()); } [[__nodiscard__]] reverse_iterator rbegin() noexcept { return reverse_iterator(this->end()); } [[__nodiscard__]] const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(this->end()); } [[__nodiscard__]] reverse_iterator rend() noexcept { return reverse_iterator(this->begin()); } [[__nodiscard__]] const_reverse_iterator rend() const noexcept { return const_reverse_iterator(this->begin()); } [[__nodiscard__]] const_iterator cbegin() const noexcept { return const_iterator(this->_M_data()); } [[__nodiscard__]] const_iterator cend() const noexcept { return const_iterator(this->_M_data() + this->size()); } [[__nodiscard__]] const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); } [[__nodiscard__]] const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); } public: [[__nodiscard__]] size_type size() const noexcept { size_type __sz = _M_string_length; if (__sz > max_size ()) __builtin_unreachable (); return __sz; } [[__nodiscard__]] size_type length() const noexcept { return size(); } [[__nodiscard__]] size_type max_size() const noexcept { const size_t __diffmax = __gnu_cxx::__numeric_traits::__max / sizeof(_CharT); const size_t __allocmax = _Alloc_traits::max_size(_M_get_allocator()); return (std::min)(__diffmax, __allocmax) - 1; } # 1199 "/usr/include/c++/15/bits/basic_string.h" 3 void resize(size_type __n, _CharT __c); # 1213 "/usr/include/c++/15/bits/basic_string.h" 3 void resize(size_type __n) { this->resize(__n, _CharT()); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" void shrink_to_fit() noexcept { reserve(); } #pragma GCC diagnostic pop # 1266 "/usr/include/c++/15/bits/basic_string.h" 3 template void __resize_and_overwrite(size_type __n, _Operation __op); [[__nodiscard__]] size_type capacity() const noexcept { size_t __sz = _M_is_local() ? size_type(_S_local_capacity) : _M_allocated_capacity; if (__sz < _S_local_capacity || __sz > max_size ()) __builtin_unreachable (); return __sz; } # 1303 "/usr/include/c++/15/bits/basic_string.h" 3 void reserve(size_type __res_arg); void reserve(); void clear() noexcept { _M_set_length(0); } [[__nodiscard__]] bool empty() const noexcept { return _M_string_length == 0; } # 1345 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] const_reference operator[] (size_type __pos) const noexcept { do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) std::__glibcxx_assert_fail(); } while (false); return _M_data()[__pos]; } # 1363 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] reference operator[](size_type __pos) { do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) std::__glibcxx_assert_fail(); } while (false); ; return _M_data()[__pos]; } # 1385 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] const_reference at(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); return _M_data()[__n]; } # 1407 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] reference at(size_type __n) { if (__n >= size()) __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); return _M_data()[__n]; } [[__nodiscard__]] reference front() noexcept { do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false); return operator[](0); } [[__nodiscard__]] const_reference front() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false); return operator[](0); } [[__nodiscard__]] reference back() noexcept { do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false); return operator[](this->size() - 1); } [[__nodiscard__]] const_reference back() const noexcept { do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false); return operator[](this->size() - 1); } # 1475 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& operator+=(const basic_string& __str) { return this->append(__str); } basic_string& operator+=(const _CharT* __s) { return this->append(__s); } basic_string& operator+=(_CharT __c) { this->push_back(__c); return *this; } basic_string& operator+=(initializer_list<_CharT> __l) { return this->append(__l.begin(), __l.size()); } # 1521 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> operator+=(const _Tp& __svt) { return this->append(__svt); } basic_string& append(const basic_string& __str) { return this->append(__str._M_data(), __str.size()); } # 1551 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& append(const basic_string& __str, size_type __pos, size_type __n = npos) { return this->append(__str._M_data() + __str._M_check(__pos, "basic_string::append"), __str._M_limit(__pos, __n)); } basic_string& append(const _CharT* __s, size_type __n) { ; _M_check_length(size_type(0), __n, "basic_string::append"); return _M_append(__s, __n); } basic_string& append(const _CharT* __s) { ; const size_type __n = traits_type::length(__s); _M_check_length(size_type(0), __n, "basic_string::append"); return _M_append(__s, __n); } # 1596 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& append(size_type __n, _CharT __c) { return _M_replace_aux(this->size(), size_type(0), __n, __c); } # 1659 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& append(initializer_list<_CharT> __l) { return this->append(__l.begin(), __l.size()); } # 1674 "/usr/include/c++/15/bits/basic_string.h" 3 template> basic_string& append(_InputIterator __first, _InputIterator __last) { return this->replace(end(), end(), __first, __last); } template _If_sv<_Tp, basic_string&> append(const _Tp& __svt) { __sv_type __sv = __svt; return this->append(__sv.data(), __sv.size()); } # 1706 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> append(const _Tp& __svt, size_type __pos, size_type __n = npos) { __sv_type __sv = __svt; return _M_append(__sv.data() + std::__sv_check(__sv.size(), __pos, "basic_string::append"), std::__sv_limit(__sv.size(), __pos, __n)); } void push_back(_CharT __c) { const size_type __size = this->size(); if (__size + 1 > this->capacity()) this->_M_mutate(__size, size_type(0), 0, size_type(1)); traits_type::assign(this->_M_data()[__size], __c); this->_M_set_length(__size + 1); } basic_string& assign(const basic_string& __str) { if (_Alloc_traits::_S_propagate_on_copy_assign()) { if (!_Alloc_traits::_S_always_equal() && !_M_is_local() && _M_get_allocator() != __str._M_get_allocator()) { if (__str.size() <= _S_local_capacity) { _M_destroy(_M_allocated_capacity); _M_data(_M_use_local_data()); _M_set_length(0); } else { const auto __len = __str.size(); auto __alloc = __str._M_get_allocator(); auto __ptr = _S_allocate(__alloc, __len + 1); _M_destroy(_M_allocated_capacity); _M_data(__ptr); _M_capacity(__len); _M_set_length(__len); } } std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator()); } this->_M_assign(__str); return *this; } # 1784 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& assign(basic_string&& __str) noexcept(_Alloc_traits::_S_nothrow_move()) { return *this = std::move(__str); } # 1808 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n = npos) { return _M_replace(size_type(0), this->size(), __str._M_data() + __str._M_check(__pos, "basic_string::assign"), __str._M_limit(__pos, __n)); } # 1825 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& assign(const _CharT* __s, size_type __n) { ; return _M_replace(size_type(0), this->size(), __s, __n); } # 1842 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& assign(const _CharT* __s) { ; return _M_replace(size_type(0), this->size(), __s, traits_type::length(__s)); } # 1860 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& assign(size_type __n, _CharT __c) { return _M_replace_aux(size_type(0), this->size(), __n, __c); } # 1874 "/usr/include/c++/15/bits/basic_string.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template> basic_string& assign(_InputIterator __first, _InputIterator __last) { using _IterTraits = iterator_traits<_InputIterator>; if constexpr (is_pointer::value && is_same::value) { ; return _M_replace(size_type(0), size(), std::__niter_base(__first), __last - __first); } # 1901 "/usr/include/c++/15/bits/basic_string.h" 3 else return *this = basic_string(__first, __last, get_allocator()); } #pragma GCC diagnostic pop # 1937 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& assign(initializer_list<_CharT> __l) { const size_type __n = __l.size(); if (__n > capacity()) *this = basic_string(__l.begin(), __l.end(), get_allocator()); else { if (__n) _S_copy(_M_data(), __l.begin(), __n); _M_set_length(__n); } return *this; } # 1962 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> assign(const _Tp& __svt) { __sv_type __sv = __svt; return this->assign(__sv.data(), __sv.size()); } # 1978 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> assign(const _Tp& __svt, size_type __pos, size_type __n = npos) { __sv_type __sv = __svt; return _M_replace(size_type(0), this->size(), __sv.data() + std::__sv_check(__sv.size(), __pos, "basic_string::assign"), std::__sv_limit(__sv.size(), __pos, __n)); } # 2007 "/usr/include/c++/15/bits/basic_string.h" 3 iterator insert(const_iterator __p, size_type __n, _CharT __c) { ; const size_type __pos = __p - begin(); this->replace(__p, __p, __n, __c); return iterator(this->_M_data() + __pos); } # 2050 "/usr/include/c++/15/bits/basic_string.h" 3 template> iterator insert(const_iterator __p, _InputIterator __beg, _InputIterator __end) { ; const size_type __pos = __p - begin(); this->replace(__p, __p, __beg, __end); return iterator(this->_M_data() + __pos); } # 2118 "/usr/include/c++/15/bits/basic_string.h" 3 iterator insert(const_iterator __p, initializer_list<_CharT> __l) { return this->insert(__p, __l.begin(), __l.end()); } # 2146 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& insert(size_type __pos1, const basic_string& __str) { return this->replace(__pos1, size_type(0), __str._M_data(), __str.size()); } # 2170 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n = npos) { return this->replace(__pos1, size_type(0), __str._M_data() + __str._M_check(__pos2, "basic_string::insert"), __str._M_limit(__pos2, __n)); } # 2194 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& insert(size_type __pos, const _CharT* __s, size_type __n) { return this->replace(__pos, size_type(0), __s, __n); } # 2214 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& insert(size_type __pos, const _CharT* __s) { ; return this->replace(__pos, size_type(0), __s, traits_type::length(__s)); } # 2239 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& insert(size_type __pos, size_type __n, _CharT __c) { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), size_type(0), __n, __c); } # 2258 "/usr/include/c++/15/bits/basic_string.h" 3 iterator insert(__const_iterator __p, _CharT __c) { ; const size_type __pos = __p - begin(); _M_replace_aux(__pos, size_type(0), size_type(1), __c); return iterator(_M_data() + __pos); } # 2275 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> insert(size_type __pos, const _Tp& __svt) { __sv_type __sv = __svt; return this->insert(__pos, __sv.data(), __sv.size()); } # 2292 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> insert(size_type __pos1, const _Tp& __svt, size_type __pos2, size_type __n = npos) { __sv_type __sv = __svt; return this->replace(__pos1, size_type(0), __sv.data() + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"), std::__sv_limit(__sv.size(), __pos2, __n)); } # 2321 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& erase(size_type __pos = 0, size_type __n = npos) { _M_check(__pos, "basic_string::erase"); if (__n == npos) this->_M_set_length(__pos); else if (__n != 0) this->_M_erase(__pos, _M_limit(__pos, __n)); return *this; } # 2341 "/usr/include/c++/15/bits/basic_string.h" 3 iterator erase(__const_iterator __position) { ; const size_type __pos = __position - begin(); this->_M_erase(__pos, size_type(1)); return iterator(_M_data() + __pos); } # 2361 "/usr/include/c++/15/bits/basic_string.h" 3 iterator erase(__const_iterator __first, __const_iterator __last) { ; const size_type __pos = __first - begin(); if (__last == end()) this->_M_set_length(__pos); else this->_M_erase(__pos, __last - __first); return iterator(this->_M_data() + __pos); } void pop_back() noexcept { do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false); _M_erase(size() - 1, 1); } # 2407 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n, const basic_string& __str) { return this->replace(__pos, __n, __str._M_data(), __str.size()); } # 2430 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) { return this->replace(__pos1, __n1, __str._M_data() + __str._M_check(__pos2, "basic_string::replace"), __str._M_limit(__pos2, __n2)); } # 2456 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) { ; return _M_replace(_M_check(__pos, "basic_string::replace"), _M_limit(__pos, __n1), __s, __n2); } # 2482 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s) { ; return this->replace(__pos, __n1, __s, traits_type::length(__s)); } # 2507 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), _M_limit(__pos, __n1), __n2, __c); } # 2526 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, const basic_string& __str) { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } # 2547 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s, size_type __n) { ; return this->replace(__i1 - begin(), __i2 - __i1, __s, __n); } # 2570 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s) { ; return this->replace(__i1, __i2, __s, traits_type::length(__s)); } # 2592 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, size_type __n, _CharT __c) { ; return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); } # 2618 "/usr/include/c++/15/bits/basic_string.h" 3 template> basic_string& replace(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2) { ; ; return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, std::__false_type()); } # 2651 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, _CharT* __k1, _CharT* __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1, __k2 - __k1); } basic_string& replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __k1, const _CharT* __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1, __k2 - __k1); } basic_string& replace(__const_iterator __i1, __const_iterator __i2, iterator __k1, iterator __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1.base(), __k2 - __k1); } basic_string& replace(__const_iterator __i1, __const_iterator __i2, const_iterator __k1, const_iterator __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1.base(), __k2 - __k1); } # 2738 "/usr/include/c++/15/bits/basic_string.h" 3 basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<_CharT> __l) { return this->replace(__i1, __i2, __l.begin(), __l.size()); } # 2752 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> replace(size_type __pos, size_type __n, const _Tp& __svt) { __sv_type __sv = __svt; return this->replace(__pos, __n, __sv.data(), __sv.size()); } # 2770 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> replace(size_type __pos1, size_type __n1, const _Tp& __svt, size_type __pos2, size_type __n2 = npos) { __sv_type __sv = __svt; return this->replace(__pos1, __n1, __sv.data() + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"), std::__sv_limit(__sv.size(), __pos2, __n2)); } # 2792 "/usr/include/c++/15/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt) { __sv_type __sv = __svt; return this->replace(__i1 - begin(), __i2 - __i1, __sv); } private: template basic_string& _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _Integer __n, _Integer __val, __true_type) { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); } template basic_string& _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2, __false_type); basic_string& _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, _CharT __c); __attribute__((__noinline__, __noclone__, __cold__)) void _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s, const size_type __len2, const size_type __how_much); basic_string& _M_replace(size_type __pos, size_type __len1, const _CharT* __s, const size_type __len2); basic_string& _M_append(const _CharT* __s, size_type __n); public: # 2849 "/usr/include/c++/15/bits/basic_string.h" 3 size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const; # 2860 "/usr/include/c++/15/bits/basic_string.h" 3 void swap(basic_string& __s) noexcept; # 2871 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] const _CharT* c_str() const noexcept { return _M_data(); } # 2884 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] const _CharT* data() const noexcept { return _M_data(); } # 2896 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] _CharT* data() noexcept { return _M_data(); } [[__nodiscard__]] allocator_type get_allocator() const noexcept { return _M_get_allocator(); } # 2922 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2937 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find(const basic_string& __str, size_type __pos = 0) const noexcept { return this->find(__str.data(), __pos, __str.size()); } # 2950 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, size_type> find(const _Tp& __svt, size_type __pos = 0) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find(__sv.data(), __pos, __sv.size()); } # 2971 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find(const _CharT* __s, size_type __pos = 0) const noexcept { ; return this->find(__s, __pos, traits_type::length(__s)); } # 2989 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find(_CharT __c, size_type __pos = 0) const noexcept; # 3003 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type rfind(const basic_string& __str, size_type __pos = npos) const noexcept { return this->rfind(__str.data(), __pos, __str.size()); } # 3016 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, size_type> rfind(const _Tp& __svt, size_type __pos = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->rfind(__sv.data(), __pos, __sv.size()); } # 3039 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 3054 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type rfind(const _CharT* __s, size_type __pos = npos) const { ; return this->rfind(__s, __pos, traits_type::length(__s)); } # 3072 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type rfind(_CharT __c, size_type __pos = npos) const noexcept; # 3087 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_of(const basic_string& __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str.data(), __pos, __str.size()); } # 3101 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, size_type> find_first_of(const _Tp& __svt, size_type __pos = 0) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_first_of(__sv.data(), __pos, __sv.size()); } # 3124 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 3139 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_of(const _CharT* __s, size_type __pos = 0) const noexcept { ; return this->find_first_of(__s, __pos, traits_type::length(__s)); } # 3160 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_of(_CharT __c, size_type __pos = 0) const noexcept { return this->find(__c, __pos); } # 3176 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_of(const basic_string& __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str.data(), __pos, __str.size()); } # 3190 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, size_type> find_last_of(const _Tp& __svt, size_type __pos = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_last_of(__sv.data(), __pos, __sv.size()); } # 3213 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 3228 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_of(const _CharT* __s, size_type __pos = npos) const noexcept { ; return this->find_last_of(__s, __pos, traits_type::length(__s)); } # 3249 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_of(_CharT __c, size_type __pos = npos) const noexcept { return this->rfind(__c, __pos); } # 3264 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str.data(), __pos, __str.size()); } # 3278 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, size_type> find_first_not_of(const _Tp& __svt, size_type __pos = 0) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_first_not_of(__sv.data(), __pos, __sv.size()); } # 3301 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 3316 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const noexcept { ; return this->find_first_not_of(__s, __pos, traits_type::length(__s)); } # 3335 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; # 3351 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str.data(), __pos, __str.size()); } # 3365 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, size_type> find_last_not_of(const _Tp& __svt, size_type __pos = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_last_not_of(__sv.data(), __pos, __sv.size()); } # 3388 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 3403 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const noexcept { ; return this->find_last_not_of(__s, __pos, traits_type::length(__s)); } # 3422 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] size_type find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; # 3439 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] basic_string substr(size_type __pos = 0, size_type __n = npos) const { return basic_string(*this, _M_check(__pos, "basic_string::substr"), __n); } # 3459 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] int compare(const basic_string& __str) const { const size_type __size = this->size(); const size_type __osize = __str.size(); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __str.data(), __len); if (!__r) __r = _S_compare(__size, __osize); return __r; } template [[__nodiscard__]] _If_sv<_Tp, int> compare(const _Tp& __svt) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; const size_type __size = this->size(); const size_type __osize = __sv.size(); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __sv.data(), __len); if (!__r) __r = _S_compare(__size, __osize); return __r; } # 3504 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, int> compare(size_type __pos, size_type __n, const _Tp& __svt) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return __sv_type(*this).substr(__pos, __n).compare(__sv); } # 3524 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] _If_sv<_Tp, int> compare(size_type __pos1, size_type __n1, const _Tp& __svt, size_type __pos2, size_type __n2 = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return __sv_type(*this) .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); } # 3556 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] int compare(size_type __pos, size_type __n, const basic_string& __str) const { _M_check(__pos, "basic_string::compare"); __n = _M_limit(__pos, __n); const size_type __osize = __str.size(); const size_type __len = std::min(__n, __osize); int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); if (!__r) __r = _S_compare(__n, __osize); return __r; } # 3593 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) const { _M_check(__pos1, "basic_string::compare"); __str._M_check(__pos2, "basic_string::compare"); __n1 = _M_limit(__pos1, __n1); __n2 = __str._M_limit(__pos2, __n2); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos1, __str.data() + __pos2, __len); if (!__r) __r = _S_compare(__n1, __n2); return __r; } # 3624 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] int compare(const _CharT* __s) const noexcept { ; const size_type __size = this->size(); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __s, __len); if (!__r) __r = _S_compare(__size, __osize); return __r; } # 3659 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] int compare(size_type __pos, size_type __n1, const _CharT* __s) const { ; _M_check(__pos, "basic_string::compare"); __n1 = _M_limit(__pos, __n1); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__n1, __osize); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = _S_compare(__n1, __osize); return __r; } # 3698 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] int compare(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) const { ; _M_check(__pos, "basic_string::compare"); __n1 = _M_limit(__pos, __n1); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = _S_compare(__n1, __n2); return __r; } # 3763 "/usr/include/c++/15/bits/basic_string.h" 3 template friend class basic_stringbuf; }; } } namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { template::value_type, typename _Allocator = allocator<_CharT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>> basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator()) -> basic_string<_CharT, char_traits<_CharT>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator()) -> basic_string<_CharT, _Traits, _Allocator>; template, typename = _RequireAllocator<_Allocator>> basic_string(basic_string_view<_CharT, _Traits>, typename basic_string<_CharT, _Traits, _Allocator>::size_type, typename basic_string<_CharT, _Traits, _Allocator>::size_type, const _Allocator& = _Allocator()) -> basic_string<_CharT, _Traits, _Allocator>; # 3809 "/usr/include/c++/15/bits/basic_string.h" 3 } template inline _Str __str_concat(typename _Str::value_type const* __lhs, typename _Str::size_type __lhs_len, typename _Str::value_type const* __rhs, typename _Str::size_type __rhs_len, typename _Str::allocator_type const& __a) { typedef typename _Str::allocator_type allocator_type; typedef __gnu_cxx::__alloc_traits _Alloc_traits; _Str __str(_Alloc_traits::_S_select_on_copy(__a)); __str.reserve(__lhs_len + __rhs_len); __str.append(__lhs, __lhs_len); __str.append(__rhs, __rhs_len); return __str; } # 3837 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> _Str; return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), __rhs.c_str(), __rhs.size(), __lhs.get_allocator()); } template [[__nodiscard__]] inline basic_string<_CharT,_Traits,_Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs) { ; typedef basic_string<_CharT, _Traits, _Alloc> _Str; return std::__str_concat<_Str>(__lhs, _Traits::length(__lhs), __rhs.c_str(), __rhs.size(), __rhs.get_allocator()); } template [[__nodiscard__]] inline basic_string<_CharT,_Traits,_Alloc> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> _Str; return std::__str_concat<_Str>(__builtin_addressof(__lhs), 1, __rhs.c_str(), __rhs.size(), __rhs.get_allocator()); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { ; typedef basic_string<_CharT, _Traits, _Alloc> _Str; return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), __rhs, _Traits::length(__rhs), __lhs.get_allocator()); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> _Str; return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), __builtin_addressof(__rhs), 1, __lhs.get_allocator()); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return std::move(__lhs.append(__rhs)); } template inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) { return std::move(__rhs.insert(0, __lhs)); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) { using _Alloc_traits = allocator_traits<_Alloc>; bool __use_rhs = false; if constexpr (typename _Alloc_traits::is_always_equal{}) __use_rhs = true; else if (__lhs.get_allocator() == __rhs.get_allocator()) __use_rhs = true; if (__use_rhs) { const auto __size = __lhs.size() + __rhs.size(); if (__size > __lhs.capacity() && __size <= __rhs.capacity()) return std::move(__rhs.insert(0, __lhs)); } return std::move(__lhs.append(__rhs)); } template [[__nodiscard__]] [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(const _CharT* __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) { return std::move(__rhs.insert(0, __lhs)); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(_CharT __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) { return std::move(__rhs.insert(0, 1, __lhs)); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, const _CharT* __rhs) { return std::move(__lhs.append(__rhs)); } template [[__nodiscard__]] inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, _CharT __rhs) { return std::move(__lhs.append(1, __rhs)); } # 4042 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return __lhs.size() == __rhs.size() && !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size()); } template [[__nodiscard__]] inline bool operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.size() == _Traits::length(__rhs) && !_Traits::compare(__lhs.data(), __rhs, __lhs.size()); } # 4106 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator==(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs == __lhs; } # 4120 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return !(__lhs == __rhs); } template [[__nodiscard__]] inline bool operator!=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return !(__rhs == __lhs); } template [[__nodiscard__]] inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return !(__lhs == __rhs); } # 4161 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return __lhs.compare(__rhs) < 0; } template [[__nodiscard__]] inline bool operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) < 0; } template [[__nodiscard__]] inline bool operator<(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) > 0; } # 4202 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return __lhs.compare(__rhs) > 0; } template [[__nodiscard__]] inline bool operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) > 0; } template [[__nodiscard__]] inline bool operator>(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) < 0; } # 4243 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return __lhs.compare(__rhs) <= 0; } template [[__nodiscard__]] inline bool operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) <= 0; } template [[__nodiscard__]] inline bool operator<=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) >= 0; } # 4284 "/usr/include/c++/15/bits/basic_string.h" 3 template [[__nodiscard__]] inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return __lhs.compare(__rhs) >= 0; } template [[__nodiscard__]] inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) >= 0; } template [[__nodiscard__]] inline bool operator>=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) <= 0; } # 4326 "/usr/include/c++/15/bits/basic_string.h" 3 template inline void swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } # 4347 "/usr/include/c++/15/bits/basic_string.h" 3 template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str); template<> basic_istream& operator>>(basic_istream& __is, basic_string& __str); # 4365 "/usr/include/c++/15/bits/basic_string.h" 3 template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Alloc>& __str) { return __ostream_insert(__os, __str.data(), __str.size()); } # 4388 "/usr/include/c++/15/bits/basic_string.h" 3 template basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); # 4405 "/usr/include/c++/15/bits/basic_string.h" 3 template inline basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str) { return std::getline(__is, __str, __is.widen('\n')); } template inline basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>&& __is, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) { return std::getline(__is, __str, __delim); } template inline basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>&& __is, basic_string<_CharT, _Traits, _Alloc>& __str) { return std::getline(__is, __str); } template<> basic_istream& getline(basic_istream& __in, basic_string& __str, char __delim); template<> basic_istream& getline(basic_istream& __in, basic_string& __str, wchar_t __delim); } # 1 "/usr/include/c++/15/ext/string_conversions.h" 1 3 # 45 "/usr/include/c++/15/ext/string_conversions.h" 3 # 1 "/usr/include/c++/15/cstdlib" 1 3 # 80 "/usr/include/c++/15/cstdlib" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" # 1 "/usr/include/stdlib.h" 1 3 4 # 26 "/usr/include/stdlib.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/stdlib.h" 2 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 33 "/usr/include/stdlib.h" 2 3 4 extern "C" { # 1 "/usr/include/riscv64-linux-gnu/bits/waitflags.h" 1 3 4 # 41 "/usr/include/stdlib.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/waitstatus.h" 1 3 4 # 42 "/usr/include/stdlib.h" 2 3 4 # 59 "/usr/include/stdlib.h" 3 4 typedef struct { int quot; int rem; } div_t; typedef struct { long int quot; long int rem; } ldiv_t; __extension__ typedef struct { long long int quot; long long int rem; } lldiv_t; # 98 "/usr/include/stdlib.h" 3 4 extern size_t __ctype_get_mb_cur_max (void) noexcept (true) __attribute__ ((__warn_unused_result__)); extern double atof (const char *__nptr) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int atoi (const char *__nptr) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern long int atol (const char *__nptr) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); __extension__ extern long long int atoll (const char *__nptr) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern double strtod (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern float strtof (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern long double strtold (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); # 141 "/usr/include/stdlib.h" 3 4 extern _Float32 strtof32 (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern _Float64 strtof64 (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern _Float128 strtof128 (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern _Float32x strtof32x (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); extern _Float64x strtof64x (const char *__restrict __nptr, char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); # 177 "/usr/include/stdlib.h" 3 4 extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); __extension__ extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); __extension__ extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); __extension__ extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); __extension__ extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __attribute__ ((__nonnull__ (1))); extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") __attribute__ ((__nonnull__ (1))); extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") __attribute__ ((__nonnull__ (1))); __extension__ extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") __attribute__ ((__nonnull__ (1))); __extension__ extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") __attribute__ ((__nonnull__ (1))); __extension__ extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") __attribute__ ((__nonnull__ (1))); __extension__ extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") __attribute__ ((__nonnull__ (1))); # 278 "/usr/include/stdlib.h" 3 4 extern int strfromd (char *__dest, size_t __size, const char *__format, double __f) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int strfromf (char *__dest, size_t __size, const char *__format, float __f) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int strfroml (char *__dest, size_t __size, const char *__format, long double __f) noexcept (true) __attribute__ ((__nonnull__ (3))); # 298 "/usr/include/stdlib.h" 3 4 extern int strfromf32 (char *__dest, size_t __size, const char * __format, _Float32 __f) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int strfromf64 (char *__dest, size_t __size, const char * __format, _Float64 __f) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int strfromf128 (char *__dest, size_t __size, const char * __format, _Float128 __f) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int strfromf32x (char *__dest, size_t __size, const char * __format, _Float32x __f) noexcept (true) __attribute__ ((__nonnull__ (3))); extern int strfromf64x (char *__dest, size_t __size, const char * __format, _Float64x __f) noexcept (true) __attribute__ ((__nonnull__ (3))); # 340 "/usr/include/stdlib.h" 3 4 extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); __extension__ extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); __extension__ extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") __attribute__ ((__nonnull__ (1, 4))); extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") __attribute__ ((__nonnull__ (1, 4))); __extension__ extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") __attribute__ ((__nonnull__ (1, 4))); __extension__ extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") __attribute__ ((__nonnull__ (1, 4))); # 415 "/usr/include/stdlib.h" 3 4 extern double strtod_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern float strtof_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern long double strtold_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); # 436 "/usr/include/stdlib.h" 3 4 extern _Float32 strtof32_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern _Float64 strtof64_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern _Float128 strtof128_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern _Float32x strtof32x_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); extern _Float64x strtof64x_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); # 480 "/usr/include/stdlib.h" 3 4 extern __inline __attribute__ ((__gnu_inline__)) int __attribute__ ((__leaf__)) atoi (const char *__nptr) noexcept (true) { return (int) strtol (__nptr, (char **) __null, 10); } extern __inline __attribute__ ((__gnu_inline__)) long int __attribute__ ((__leaf__)) atol (const char *__nptr) noexcept (true) { return strtol (__nptr, (char **) __null, 10); } __extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int __attribute__ ((__leaf__)) atoll (const char *__nptr) noexcept (true) { return strtoll (__nptr, (char **) __null, 10); } # 505 "/usr/include/stdlib.h" 3 4 extern char *l64a (long int __n) noexcept (true) __attribute__ ((__warn_unused_result__)); extern long int a64l (const char *__s) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 1 "/usr/include/riscv64-linux-gnu/sys/types.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 extern "C" { typedef __u_char u_char; typedef __u_short u_short; typedef __u_int u_int; typedef __u_long u_long; typedef __quad_t quad_t; typedef __u_quad_t u_quad_t; typedef __fsid_t fsid_t; typedef __loff_t loff_t; typedef __ino64_t ino_t; typedef __ino64_t ino64_t; typedef __dev_t dev_t; typedef __gid_t gid_t; typedef __mode_t mode_t; typedef __nlink_t nlink_t; typedef __uid_t uid_t; typedef __off64_t off_t; typedef __off64_t off64_t; # 103 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 typedef __id_t id_t; typedef __ssize_t ssize_t; typedef __daddr_t daddr_t; typedef __caddr_t caddr_t; typedef __key_t key_t; # 134 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 typedef __useconds_t useconds_t; typedef __suseconds_t suseconds_t; # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 145 "/usr/include/riscv64-linux-gnu/sys/types.h" 2 3 4 typedef unsigned long int ulong; typedef unsigned short int ushort; typedef unsigned int uint; typedef __uint8_t u_int8_t; typedef __uint16_t u_int16_t; typedef __uint32_t u_int32_t; typedef __uint64_t u_int64_t; typedef int register_t __attribute__ ((__mode__ (__word__))); # 176 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 # 1 "/usr/include/endian.h" 1 3 4 # 35 "/usr/include/endian.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/byteswap.h" 1 3 4 # 33 "/usr/include/riscv64-linux-gnu/bits/byteswap.h" 3 4 static __inline __uint16_t __bswap_16 (__uint16_t __bsx) { return __builtin_bswap16 (__bsx); } static __inline __uint32_t __bswap_32 (__uint32_t __bsx) { return __builtin_bswap32 (__bsx); } # 69 "/usr/include/riscv64-linux-gnu/bits/byteswap.h" 3 4 __extension__ static __inline __uint64_t __bswap_64 (__uint64_t __bsx) { return __builtin_bswap64 (__bsx); } # 36 "/usr/include/endian.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/uintn-identity.h" 1 3 4 # 32 "/usr/include/riscv64-linux-gnu/bits/uintn-identity.h" 3 4 static __inline __uint16_t __uint16_identity (__uint16_t __x) { return __x; } static __inline __uint32_t __uint32_identity (__uint32_t __x) { return __x; } static __inline __uint64_t __uint64_identity (__uint64_t __x) { return __x; } # 37 "/usr/include/endian.h" 2 3 4 # 177 "/usr/include/riscv64-linux-gnu/sys/types.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/sys/select.h" 1 3 4 # 30 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/select.h" 1 3 4 # 31 "/usr/include/riscv64-linux-gnu/sys/select.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/sigset_t.h" 1 3 4 typedef __sigset_t sigset_t; # 34 "/usr/include/riscv64-linux-gnu/sys/select.h" 2 3 4 # 49 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 typedef long int __fd_mask; # 59 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 typedef struct { __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; } fd_set; typedef __fd_mask fd_mask; # 91 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 extern "C" { # 102 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 extern int select (int __nfds, fd_set *__restrict __readfds, fd_set *__restrict __writefds, fd_set *__restrict __exceptfds, struct timeval *__restrict __timeout); # 127 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 extern int pselect (int __nfds, fd_set *__restrict __readfds, fd_set *__restrict __writefds, fd_set *__restrict __exceptfds, const struct timespec *__restrict __timeout, const __sigset_t *__restrict __sigmask); # 150 "/usr/include/riscv64-linux-gnu/sys/select.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/select2.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/select2.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/select-decl.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/select-decl.h" 3 4 extern long int __fdelt_chk (long int __d); extern long int __fdelt_warn (long int __d) __attribute__((__warning__ ("bit outside of fd_set selected"))); # 24 "/usr/include/riscv64-linux-gnu/bits/select2.h" 2 3 4 # 151 "/usr/include/riscv64-linux-gnu/sys/select.h" 2 3 4 } # 180 "/usr/include/riscv64-linux-gnu/sys/types.h" 2 3 4 typedef __blksize_t blksize_t; # 205 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 typedef __blkcnt64_t blkcnt_t; typedef __fsblkcnt64_t fsblkcnt_t; typedef __fsfilcnt64_t fsfilcnt_t; typedef __blkcnt64_t blkcnt64_t; typedef __fsblkcnt64_t fsblkcnt64_t; typedef __fsfilcnt64_t fsfilcnt64_t; # 230 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 } # 515 "/usr/include/stdlib.h" 2 3 4 extern long int random (void) noexcept (true); extern void srandom (unsigned int __seed) noexcept (true); extern char *initstate (unsigned int __seed, char *__statebuf, size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); struct random_data { int32_t *fptr; int32_t *rptr; int32_t *state; int rand_type; int rand_deg; int rand_sep; int32_t *end_ptr; }; extern int random_r (struct random_data *__restrict __buf, int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int srandom_r (unsigned int __seed, struct random_data *__buf) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, size_t __statelen, struct random_data *__restrict __buf) noexcept (true) __attribute__ ((__nonnull__ (2, 4))); extern int setstate_r (char *__restrict __statebuf, struct random_data *__restrict __buf) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int rand (void) noexcept (true); extern void srand (unsigned int __seed) noexcept (true); extern int rand_r (unsigned int *__seed) noexcept (true); extern double drand48 (void) noexcept (true); extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); extern long int lrand48 (void) noexcept (true); extern long int nrand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); extern long int mrand48 (void) noexcept (true); extern long int jrand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); extern void srand48 (long int __seedval) noexcept (true); extern unsigned short int *seed48 (unsigned short int __seed16v[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); struct drand48_data { unsigned short int __x[3]; unsigned short int __old_x[3]; unsigned short int __c; unsigned short int __init; __extension__ unsigned long long int __a; }; extern int drand48_r (struct drand48_data *__restrict __buffer, double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int erand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int lrand48_r (struct drand48_data *__restrict __buffer, long int *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int nrand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, long int *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int mrand48_r (struct drand48_data *__restrict __buffer, long int *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int jrand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, long int *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int srand48_r (long int __seedval, struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int seed48_r (unsigned short int __seed16v[3], struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int lcong48_r (unsigned short int __param[7], struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern __uint32_t arc4random (void) noexcept (true) __attribute__ ((__warn_unused_result__)); extern void arc4random_buf (void *__buf, size_t __size) noexcept (true) __attribute__ ((__nonnull__ (1))); extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) noexcept (true) __attribute__ ((__warn_unused_result__)); extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__)); extern void *calloc (size_t __nmemb, size_t __size) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) __attribute__ ((__warn_unused_result__)); extern void *realloc (void *__ptr, size_t __size) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); extern void free (void *__ptr) noexcept (true); extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2, 3))) __attribute__ ((__malloc__ (__builtin_free, 1))); extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); # 1 "/usr/include/alloca.h" 1 3 4 # 24 "/usr/include/alloca.h" 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 25 "/usr/include/alloca.h" 2 3 4 extern "C" { extern void *alloca (size_t __size) noexcept (true); } # 707 "/usr/include/stdlib.h" 2 3 4 extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__)); extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern void *aligned_alloc (size_t __alignment, size_t __size) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) __attribute__ ((__alloc_size__ (2))) __attribute__ ((__warn_unused_result__)); extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)) __attribute__ ((__cold__)); extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); extern "C++" int at_quick_exit (void (*__func) (void)) noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); # 749 "/usr/include/stdlib.h" 3 4 extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) noexcept (true) __attribute__ ((__nonnull__ (1))); extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern char *secure_getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int setenv (const char *__name, const char *__value, int __replace) noexcept (true) __attribute__ ((__nonnull__ (2))); extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int clearenv (void) noexcept (true); # 814 "/usr/include/stdlib.h" 3 4 extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); # 830 "/usr/include/stdlib.h" 3 4 extern int mkstemp (char *__template) __asm__ ("" "mkstemp64") __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 852 "/usr/include/stdlib.h" 3 4 extern int mkstemps (char *__template, int __suffixlen) __asm__ ("" "mkstemps64") __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int mkstemps64 (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 870 "/usr/include/stdlib.h" 3 4 extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 884 "/usr/include/stdlib.h" 3 4 extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64") __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 905 "/usr/include/stdlib.h" 3 4 extern int mkostemps (char *__template, int __suffixlen, int __flags) __asm__ ("" "mkostemps64") __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); extern int mkostemps64 (char *__template, int __suffixlen, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 923 "/usr/include/stdlib.h" 3 4 extern int system (const char *__command) __attribute__ ((__warn_unused_result__)); extern char *canonicalize_file_name (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1))) __attribute__ ((__warn_unused_result__)); # 940 "/usr/include/stdlib.h" 3 4 extern char *realpath (const char *__restrict __name, char *__restrict __resolved) noexcept (true) __attribute__ ((__warn_unused_result__)); typedef int (*__compar_fn_t) (const void *, const void *); typedef __compar_fn_t comparison_fn_t; typedef int (*__compar_d_fn_t) (const void *, const void *, void *); extern void *bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__)); # 1 "/usr/include/riscv64-linux-gnu/bits/stdlib-bsearch.h" 1 3 4 # 19 "/usr/include/riscv64-linux-gnu/bits/stdlib-bsearch.h" 3 4 extern __inline __attribute__ ((__gnu_inline__)) void * bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) { const void *__p; int __comparison; while (__nmemb) { __p = (const void *) (((const char *) __base) + ((__nmemb >> 1) * __size)); __comparison = (*__compar) (__key, __p); if (__comparison == 0) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-qual" return (void *) __p; #pragma GCC diagnostic pop } if (__comparison > 0) { __base = ((const char *) __p) + __size; --__nmemb; } __nmemb >>= 1; } return __null; } # 966 "/usr/include/stdlib.h" 2 3 4 extern void qsort (void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); extern void qsort_r (void *__base, size_t __nmemb, size_t __size, __compar_d_fn_t __compar, void *__arg) __attribute__ ((__nonnull__ (1, 4))); extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); __extension__ extern long long int llabs (long long int __x) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern unsigned int uabs (int __x) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern unsigned long int ulabs (long int __x) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); __extension__ extern unsigned long long int ullabs (long long int __x) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern div_t div (int __numer, int __denom) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); extern ldiv_t ldiv (long int __numer, long int __denom) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); __extension__ extern lldiv_t lldiv (long long int __numer, long long int __denom) noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__)); # 1018 "/usr/include/stdlib.h" 3 4 extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__)); extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__)); extern char *gcvt (double __value, int __ndigit, char *__buf) noexcept (true) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__)); extern char *qecvt (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__)); extern char *qfcvt (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__)); extern char *qgcvt (long double __value, int __ndigit, char *__buf) noexcept (true) __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__)); extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); extern int qecvt_r (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); extern int qfcvt_r (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); extern int mblen (const char *__s, size_t __n) noexcept (true); extern int mbtowc (wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n) noexcept (true); extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); extern size_t mbstowcs (wchar_t *__restrict __pwcs, const char *__restrict __s, size_t __n) noexcept (true) __attribute__ ((__access__ (__read_only__, 2))); extern size_t wcstombs (char *__restrict __s, const wchar_t *__restrict __pwcs, size_t __n) noexcept (true) __attribute__ ((__access__ (__read_only__, 2))); extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); # 1105 "/usr/include/stdlib.h" 3 4 extern int getsubopt (char **__restrict __optionp, char *const *__restrict __tokens, char **__restrict __valuep) noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__)); extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__)); extern int grantpt (int __fd) noexcept (true); extern int unlockpt (int __fd) noexcept (true); extern char *ptsname (int __fd) noexcept (true) __attribute__ ((__warn_unused_result__)); extern int ptsname_r (int __fd, char *__buf, size_t __buflen) noexcept (true) __attribute__ ((__nonnull__ (2))) ; extern int getpt (void); extern int getloadavg (double __loadavg[], int __nelem) noexcept (true) __attribute__ ((__nonnull__ (1))); # 1161 "/usr/include/stdlib.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdlib-float.h" 1 3 4 # 24 "/usr/include/riscv64-linux-gnu/bits/stdlib-float.h" 3 4 extern __inline __attribute__ ((__gnu_inline__)) double __attribute__ ((__leaf__)) atof (const char *__nptr) noexcept (true) { return strtod (__nptr, (char **) __null); } # 1162 "/usr/include/stdlib.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdlib.h" 1 3 4 # 23 "/usr/include/riscv64-linux-gnu/bits/stdlib.h" 3 4 extern char *__realpath_chk (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) noexcept (true) __attribute__ ((__warn_unused_result__)); extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) noexcept (true) __asm__ ("" "realpath") __attribute__ ((__warn_unused_result__)); extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) noexcept (true) __asm__ ("" "__realpath_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer"))) ; extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char * __attribute__ ((__leaf__)) realpath (const char *__restrict __name, char * __restrict __resolved) noexcept (true) { size_t __sz = __builtin_dynamic_object_size (__resolved, 1); if (__sz == (size_t) -1) return __realpath_alias (__name, __resolved); return __realpath_chk (__name, __resolved, __sz); } extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, size_t __nreal) noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) noexcept (true) __asm__ ("" "ptsname_r") __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) noexcept (true) __asm__ ("" "__ptsname_r_chk") __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf"))) ; extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) ptsname_r (int __fd, char * __buf, size_t __buflen) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__buf, 1)) && (__builtin_dynamic_object_size (__buf, 1)) == (long unsigned int) -1) || (((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned int) (__buflen)) <= ((__builtin_dynamic_object_size (__buf, 1))) / ((sizeof (char))))) && (((long unsigned int) (__buflen)) <= ((__builtin_dynamic_object_size (__buf, 1))) / ((sizeof (char)))))) ? __ptsname_r_alias (__fd, __buf, __buflen) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned int) (__buflen)) <= (__builtin_dynamic_object_size (__buf, 1)) / (sizeof (char)))) && !(((long unsigned int) (__buflen)) <= (__builtin_dynamic_object_size (__buf, 1)) / (sizeof (char)))) ? __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_dynamic_object_size (__buf, 1)) : __ptsname_r_chk (__fd, __buf, __buflen, __builtin_dynamic_object_size (__buf, 1)))) ; } extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen) noexcept (true) __attribute__ ((__warn_unused_result__)); extern int __wctomb_alias (char *__s, wchar_t __wchar) noexcept (true) __asm__ ("" "wctomb") __attribute__ ((__warn_unused_result__)); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int __attribute__ ((__leaf__)) wctomb (char * __s, wchar_t __wchar) noexcept (true) { if (__builtin_dynamic_object_size (__s, 1) != (size_t) -1 && 16 > __builtin_dynamic_object_size (__s, 1)) return __wctomb_chk (__s, __wchar, __builtin_dynamic_object_size (__s, 1)); return __wctomb_alias (__s, __wchar); } extern size_t __mbstowcs_chk (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) noexcept (true) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __mbstowcs_nulldst (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) noexcept (true) __asm__ ("" "mbstowcs") __attribute__ ((__access__ (__read_only__, 2))); extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) noexcept (true) __asm__ ("" "mbstowcs") __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) noexcept (true) __asm__ ("" "__mbstowcs_chk") __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"))) ; extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) mbstowcs (wchar_t * __restrict __dst, const char *__restrict __src, size_t __len) noexcept (true) { if (__builtin_constant_p (__dst == __null) && __dst == __null) return __mbstowcs_nulldst (__dst, __src, __len); else return (((__builtin_constant_p (__builtin_dynamic_object_size (__dst, 1)) && (__builtin_dynamic_object_size (__dst, 1)) == (long unsigned int) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (wchar_t)))))) ? __mbstowcs_alias (__dst, __src, __len) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t)))) ? __mbstowcs_chk_warn (__dst, __src, __len, (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t))) : __mbstowcs_chk (__dst, __src, __len, (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (wchar_t))))) ; } extern size_t __wcstombs_chk (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) noexcept (true) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) noexcept (true) __asm__ ("" "wcstombs") __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2))); extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) noexcept (true) __asm__ ("" "__wcstombs_chk") __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len"))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) wcstombs (char * __restrict __dst, const wchar_t *__restrict __src, size_t __len) noexcept (true) { return (((__builtin_constant_p (__builtin_dynamic_object_size (__dst, 1)) && (__builtin_dynamic_object_size (__dst, 1)) == (long unsigned int) -1) || (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (char))))) && (((long unsigned int) (__len)) <= ((__builtin_dynamic_object_size (__dst, 1))) / ((sizeof (char)))))) ? __wcstombs_alias (__dst, __src, __len) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (char)))) && !(((long unsigned int) (__len)) <= (__builtin_dynamic_object_size (__dst, 1)) / (sizeof (char)))) ? __wcstombs_chk_warn (__dst, __src, __len, __builtin_dynamic_object_size (__dst, 1)) : __wcstombs_chk (__dst, __src, __len, __builtin_dynamic_object_size (__dst, 1)))) ; } # 1166 "/usr/include/stdlib.h" 2 3 4 } # 84 "/usr/include/c++/15/cstdlib" 2 3 # 85 "/usr/include/c++/15/cstdlib" 3 #pragma GCC diagnostic pop # 1 "/usr/include/c++/15/bits/std_abs.h" 1 3 # 39 "/usr/include/c++/15/bits/std_abs.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" #pragma GCC diagnostic ignored "-Wlong-long" # 52 "/usr/include/c++/15/bits/std_abs.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::abs; inline long abs(long __i) { return __builtin_labs(__i); } inline long long abs(long long __x) { return __builtin_llabs (__x); } # 76 "/usr/include/c++/15/bits/std_abs.h" 3 inline constexpr double abs(double __x) { return __builtin_fabs(__x); } inline constexpr float abs(float __x) { return __builtin_fabsf(__x); } inline constexpr long double abs(long double __x) { return __builtin_fabsl(__x); } __extension__ inline constexpr __int128 abs(__int128 __x) { return __x >= 0 ? __x : -__x; } # 156 "/usr/include/c++/15/bits/std_abs.h" 3 } } #pragma GCC diagnostic pop # 88 "/usr/include/c++/15/cstdlib" 2 3 # 131 "/usr/include/c++/15/cstdlib" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::div_t; using ::ldiv_t; using ::abort; using ::aligned_alloc; using ::atexit; using ::at_quick_exit; using ::atof; using ::atoi; using ::atol; using ::bsearch; using ::calloc; using ::div; using ::exit; using ::free; using ::getenv; using ::labs; using ::ldiv; using ::malloc; using ::mblen; using ::mbstowcs; using ::mbtowc; using ::qsort; using ::quick_exit; using ::rand; using ::realloc; using ::srand; using ::strtod; using ::strtol; using ::strtoul; using ::system; using ::wcstombs; using ::wctomb; inline ldiv_t div(long __i, long __j) noexcept { return ldiv(__i, __j); } } # 205 "/usr/include/c++/15/cstdlib" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { using ::lldiv_t; using ::_Exit; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" using ::llabs; inline lldiv_t div(long long __n, long long __d) { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } using ::lldiv; #pragma GCC diagnostic pop # 240 "/usr/include/c++/15/cstdlib" 3 using ::atoll; using ::strtoll; using ::strtoull; using ::strtof; using ::strtold; } namespace std { using ::__gnu_cxx::lldiv_t; using ::__gnu_cxx::_Exit; using ::__gnu_cxx::llabs; using ::__gnu_cxx::div; using ::__gnu_cxx::lldiv; using ::__gnu_cxx::atoll; using ::__gnu_cxx::strtof; using ::__gnu_cxx::strtoll; using ::__gnu_cxx::strtoull; using ::__gnu_cxx::strtold; } # 284 "/usr/include/c++/15/cstdlib" 3 } # 46 "/usr/include/c++/15/ext/string_conversions.h" 2 3 # 1 "/usr/include/c++/15/cstdio" 1 3 # 47 "/usr/include/c++/15/cstdio" 3 # 1 "/usr/include/stdio.h" 1 3 4 # 28 "/usr/include/stdio.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 29 "/usr/include/stdio.h" 2 3 4 extern "C" { # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 35 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stdarg.h" 1 3 4 # 38 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/__fpos_t.h" 1 3 4 # 10 "/usr/include/riscv64-linux-gnu/bits/types/__fpos_t.h" 3 4 typedef struct _G_fpos_t { __off_t __pos; __mbstate_t __state; } __fpos_t; # 41 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4 # 10 "/usr/include/riscv64-linux-gnu/bits/types/__fpos64_t.h" 3 4 typedef struct _G_fpos64_t { __off64_t __pos; __mbstate_t __state; } __fpos64_t; # 42 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_FILE.h" 1 3 4 # 35 "/usr/include/riscv64-linux-gnu/bits/types/struct_FILE.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 # 36 "/usr/include/riscv64-linux-gnu/bits/types/struct_FILE.h" 2 3 4 struct _IO_FILE; struct _IO_marker; struct _IO_codecvt; struct _IO_wide_data; typedef void _IO_lock_t; struct _IO_FILE { int _flags; char *_IO_read_ptr; char *_IO_read_end; char *_IO_read_base; char *_IO_write_base; char *_IO_write_ptr; char *_IO_write_end; char *_IO_buf_base; char *_IO_buf_end; char *_IO_save_base; char *_IO_backup_base; char *_IO_save_end; struct _IO_marker *_markers; struct _IO_FILE *_chain; int _fileno; int _flags2:24; char _short_backupbuf[1]; __off_t _old_offset; unsigned short _cur_column; signed char _vtable_offset; char _shortbuf[1]; _IO_lock_t *_lock; __off64_t _offset; struct _IO_codecvt *_codecvt; struct _IO_wide_data *_wide_data; struct _IO_FILE *_freeres_list; void *_freeres_buf; struct _IO_FILE **_prevchain; int _mode; int _unused3; __uint64_t _total_written; char _unused2[12 * sizeof (int) - 5 * sizeof (void *)]; }; # 45 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/types/cookie_io_functions_t.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/types/cookie_io_functions_t.h" 3 4 typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, size_t __nbytes); typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, size_t __nbytes); typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); typedef int cookie_close_function_t (void *__cookie); typedef struct _IO_cookie_io_functions_t { cookie_read_function_t *read; cookie_write_function_t *write; cookie_seek_function_t *seek; cookie_close_function_t *close; } cookie_io_functions_t; # 48 "/usr/include/stdio.h" 2 3 4 # 87 "/usr/include/stdio.h" 3 4 typedef __fpos64_t fpos_t; typedef __fpos64_t fpos64_t; # 129 "/usr/include/stdio.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdio_lim.h" 1 3 4 # 130 "/usr/include/stdio.h" 2 3 4 # 149 "/usr/include/stdio.h" 3 4 extern FILE *stdin; extern FILE *stdout; extern FILE *stderr; extern int remove (const char *__filename) noexcept (true); extern int rename (const char *__old, const char *__new) noexcept (true); extern int renameat (int __oldfd, const char *__old, int __newfd, const char *__new) noexcept (true); # 179 "/usr/include/stdio.h" 3 4 extern int renameat2 (int __oldfd, const char *__old, int __newfd, const char *__new, unsigned int __flags) noexcept (true); extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); # 201 "/usr/include/stdio.h" 3 4 extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *tmpfile64 (void) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern char *tmpnam (char[20]) noexcept (true) __attribute__ ((__warn_unused_result__)); extern char *tmpnam_r (char __s[20]) noexcept (true) __attribute__ ((__warn_unused_result__)); # 231 "/usr/include/stdio.h" 3 4 extern char *tempnam (const char *__dir, const char *__pfx) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__malloc__ (__builtin_free, 1))); extern int fflush (FILE *__stream); # 248 "/usr/include/stdio.h" 3 4 extern int fflush_unlocked (FILE *__stream); # 258 "/usr/include/stdio.h" 3 4 extern int fcloseall (void); # 279 "/usr/include/stdio.h" 3 4 extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __asm__ ("" "fopen64") __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64") __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))); extern FILE *fopen64 (const char *__restrict __filename, const char *__restrict __modes) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *freopen64 (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))); extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *fopencookie (void *__restrict __magic_cookie, const char *__restrict __modes, cookie_io_functions_t __io_funcs) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __attribute__ ((__warn_unused_result__)); extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))); extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, size_t __size) noexcept (true) __attribute__ ((__nonnull__ (1))); extern void setlinebuf (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int fprintf (FILE *__restrict __stream, const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1))); extern int printf (const char *__restrict __format, ...); extern int sprintf (char *__restrict __s, const char *__restrict __format, ...) noexcept (true); extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nonnull__ (1))); extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); extern int vsprintf (char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true); extern int snprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, ...) noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); extern int vsnprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, __gnuc_va_list __arg) noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__)); extern int __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__)); extern int asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__)); extern int vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 2, 0))); extern int dprintf (int __fd, const char *__restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int scanf (const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__)); extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true); # 445 "/usr/include/stdio.h" 3 4 extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") __attribute__ ((__warn_unused_result__)); extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf") ; # 493 "/usr/include/stdio.h" 3 4 extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__)); extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__)); extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") __attribute__ ((__format__ (__scanf__, 2, 0))); # 578 "/usr/include/stdio.h" 3 4 extern int fgetc (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern int getc (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern int getchar (void); extern int getc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern int getchar_unlocked (void); # 603 "/usr/include/stdio.h" 3 4 extern int fgetc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern int fputc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); extern int putc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); extern int putchar (int __c); # 627 "/usr/include/stdio.h" 3 4 extern int fputc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); extern int putc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); extern int putchar_unlocked (int __c); extern int getw (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern int putw (int __w, FILE *__stream) __attribute__ ((__nonnull__ (2))); extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))); # 677 "/usr/include/stdio.h" 3 4 extern char *fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))); # 689 "/usr/include/stdio.h" 3 4 extern __ssize_t __getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (4))); extern __ssize_t getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (4))); extern __ssize_t getline (char **__restrict __lineptr, size_t *__restrict __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))); extern int fputs (const char *__restrict __s, FILE *__restrict __stream) __attribute__ ((__nonnull__ (2))); extern int puts (const char *__s); extern int ungetc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2))); extern size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (4))); extern size_t fwrite (const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __s) __attribute__ ((__nonnull__ (4))); # 745 "/usr/include/stdio.h" 3 4 extern int fputs_unlocked (const char *__restrict __s, FILE *__restrict __stream) __attribute__ ((__nonnull__ (2))); # 756 "/usr/include/stdio.h" 3 4 extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (4))); extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__nonnull__ (4))); extern int fseek (FILE *__stream, long int __off, int __whence) __attribute__ ((__nonnull__ (1))); extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern void rewind (FILE *__stream) __attribute__ ((__nonnull__ (1))); # 802 "/usr/include/stdio.h" 3 4 extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64") __attribute__ ((__nonnull__ (1))); extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64") __attribute__ ((__nonnull__ (1))); # 828 "/usr/include/stdio.h" 3 4 extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64") __attribute__ ((__nonnull__ (1))); extern int fsetpos (FILE *__stream, const fpos_t *__pos) __asm__ ("" "fsetpos64") __attribute__ ((__nonnull__ (1))); extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence) __attribute__ ((__nonnull__ (1))); extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos) __attribute__ ((__nonnull__ (1))); extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos) __attribute__ ((__nonnull__ (1))); extern void clearerr (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int feof (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int ferror (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern void clearerr_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int feof_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int ferror_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern void perror (const char *__s) __attribute__ ((__cold__)); extern int fileno (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern int fileno_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); # 887 "/usr/include/stdio.h" 3 4 extern int pclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) __attribute__ ((__warn_unused_result__)); extern char *ctermid (char *__s) noexcept (true) __attribute__ ((__access__ (__write_only__, 1))); extern char *cuserid (char *__s) __attribute__ ((__access__ (__write_only__, 1))); struct obstack; extern int obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __format, ...) noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); extern int obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __format, __gnuc_va_list __args) noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); extern void flockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int ftrylockfile (FILE *__stream) noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (1))); extern void funlockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1))); # 949 "/usr/include/stdio.h" 3 4 extern int __uflow (FILE *); extern int __overflow (FILE *, int); # 1 "/usr/include/riscv64-linux-gnu/bits/stdio2-decl.h" 1 3 4 # 26 "/usr/include/riscv64-linux-gnu/bits/stdio2-decl.h" 3 4 extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen, const char *__restrict __format, ...) noexcept (true) __attribute__ ((__access__ (__write_only__, 1, 3))); extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen, const char *__restrict __format, __gnuc_va_list __ap) noexcept (true) __attribute__ ((__access__ (__write_only__, 1, 3))); extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag, size_t __slen, const char *__restrict __format, ...) noexcept (true) __attribute__ ((__access__ (__write_only__, 1, 2))); extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag, size_t __slen, const char *__restrict __format, __gnuc_va_list __ap) noexcept (true) __attribute__ ((__access__ (__write_only__, 1, 2))); extern int __fprintf_chk (FILE *__restrict __stream, int __flag, const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1))); extern int __printf_chk (int __flag, const char *__restrict __format, ...); extern int __vfprintf_chk (FILE *__restrict __stream, int __flag, const char *__restrict __format, __gnuc_va_list __ap) __attribute__ ((__nonnull__ (1))); extern int __vprintf_chk (int __flag, const char *__restrict __format, __gnuc_va_list __ap); extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4))); extern int __vdprintf_chk (int __fd, int __flag, const char *__restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 3, 0))); extern int __asprintf_chk (char **__restrict __ptr, int __flag, const char *__restrict __fmt, ...) noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__)); extern int __vasprintf_chk (char **__restrict __ptr, int __flag, const char *__restrict __fmt, __gnuc_va_list __arg) noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__)); extern int __obstack_printf_chk (struct obstack *__restrict __obstack, int __flag, const char *__restrict __format, ...) noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack, int __flag, const char *__restrict __format, __gnuc_va_list __args) noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); # 96 "/usr/include/riscv64-linux-gnu/bits/stdio2-decl.h" 3 4 extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets") __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))); extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer"))) ; extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__nonnull__ (4))); extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread") __attribute__ ((__warn_unused_result__)); extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer"))) ; extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (5))); extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked") __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))); extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer"))) ; extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__nonnull__ (4))); extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked") __attribute__ ((__warn_unused_result__)); extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk") __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer"))) ; extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (5))); # 955 "/usr/include/stdio.h" 2 3 4 # 966 "/usr/include/stdio.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdio.h" 1 3 4 # 46 "/usr/include/riscv64-linux-gnu/bits/stdio.h" 3 4 extern __inline __attribute__ ((__gnu_inline__)) int getchar (void) { return getc (stdin); } extern __inline __attribute__ ((__gnu_inline__)) int fgetc_unlocked (FILE *__fp) { return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); } extern __inline __attribute__ ((__gnu_inline__)) int getc_unlocked (FILE *__fp) { return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); } extern __inline __attribute__ ((__gnu_inline__)) int getchar_unlocked (void) { return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); } extern __inline __attribute__ ((__gnu_inline__)) int putchar (int __c) { return putc (__c, stdout); } extern __inline __attribute__ ((__gnu_inline__)) int fputc_unlocked (int __c, FILE *__stream) { return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); } extern __inline __attribute__ ((__gnu_inline__)) int putc_unlocked (int __c, FILE *__stream) { return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); } extern __inline __attribute__ ((__gnu_inline__)) int putchar_unlocked (int __c) { return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); } extern __inline __attribute__ ((__gnu_inline__)) __ssize_t getline (char **__lineptr, size_t *__n, FILE *__stream) { return __getdelim (__lineptr, __n, '\n', __stream); } extern __inline __attribute__ ((__gnu_inline__)) int __attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) noexcept (true) { return (((__stream)->_flags & 0x0010) != 0); } extern __inline __attribute__ ((__gnu_inline__)) int __attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) noexcept (true) { return (((__stream)->_flags & 0x0020) != 0); } # 967 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 1 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) sprintf (char *__restrict __s, const char *__restrict __fmt, ...) noexcept (true) { return __builtin___sprintf_chk (__s, 3 - 1, __builtin_dynamic_object_size (__s, 1), __fmt, __builtin_va_arg_pack ()); } # 54 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) vsprintf (char * __restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) { return __builtin___vsprintf_chk (__s, 3 - 1, __builtin_dynamic_object_size (__s, 1), __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...) noexcept (true) { return __builtin___snprintf_chk (__s, __n, 3 - 1, __builtin_dynamic_object_size (__s, 1), __fmt, __builtin_va_arg_pack ()); } # 92 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) vsnprintf (char * __restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) { return __builtin___vsnprintf_chk (__s, __n, 3 - 1, __builtin_dynamic_object_size (__s, 1), __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) int fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...) { return __fprintf_chk (__stream, 3 - 1, __fmt, __builtin_va_arg_pack ()); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int printf (const char *__restrict __fmt, ...) { return __printf_chk (3 - 1, __fmt, __builtin_va_arg_pack ()); } # 151 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int vprintf (const char * __restrict __fmt, __gnuc_va_list __ap) { return __vfprintf_chk (stdout, 3 - 1, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) int vfprintf (FILE *__restrict __stream, const char *__restrict __fmt, __gnuc_va_list __ap) { return __vfprintf_chk (__stream, 3 - 1, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int dprintf (int __fd, const char *__restrict __fmt, ...) { return __dprintf_chk (__fd, 3 - 1, __fmt, __builtin_va_arg_pack ()); } # 194 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap) { return __vdprintf_chk (__fd, 3 - 1, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) noexcept (true) { return __asprintf_chk (__ptr, 3 - 1, __fmt, __builtin_va_arg_pack ()); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) noexcept (true) { return __asprintf_chk (__ptr, 3 - 1, __fmt, __builtin_va_arg_pack ()); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __fmt, ...) noexcept (true) { return __obstack_printf_chk (__obstack, 3 - 1, __fmt, __builtin_va_arg_pack ()); } # 271 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) vasprintf (char **__restrict __ptr, const char *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) { return __vasprintf_chk (__ptr, 3 - 1, __fmt, __ap); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int __attribute__ ((__leaf__)) obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) { return __obstack_vprintf_chk (__obstack, 3 - 1, __fmt, __ap); } # 303 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))) char * fgets (char * __restrict __s, int __n, FILE *__restrict __stream) { size_t __sz = __builtin_dynamic_object_size (__s, 1); if (((__builtin_constant_p (__sz) && (__sz) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (char))))) && (((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (char))))))) return __fgets_alias (__s, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__sz) / (sizeof (char)))) && !(((long unsigned int) (__n)) <= (__sz) / (sizeof (char))))) return __fgets_chk_warn (__s, __sz, __n, __stream); return __fgets_chk (__s, __sz, __n, __stream); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (4))) size_t fread (void * __restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) { size_t __sz = __builtin_dynamic_object_size (__ptr, 0); if (((__builtin_constant_p (__sz) && (__sz) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__sz)) / ((__size)))) && (((long unsigned int) (__n)) <= ((__sz)) / ((__size)))))) return __fread_alias (__ptr, __size, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__sz) / (__size))) && !(((long unsigned int) (__n)) <= (__sz) / (__size)))) return __fread_chk_warn (__ptr, __sz, __size, __n, __stream); return __fread_chk (__ptr, __sz, __size, __n, __stream); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (3))) char * fgets_unlocked (char * __restrict __s, int __n, FILE *__restrict __stream) { size_t __sz = __builtin_dynamic_object_size (__s, 1); if (((__builtin_constant_p (__sz) && (__sz) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (char))))) && (((long unsigned int) (__n)) <= ((__sz)) / ((sizeof (char))))))) return __fgets_unlocked_alias (__s, __n, __stream); if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__sz) / (sizeof (char)))) && !(((long unsigned int) (__n)) <= (__sz) / (sizeof (char))))) return __fgets_unlocked_chk_warn (__s, __sz, __n, __stream); return __fgets_unlocked_chk (__s, __sz, __n, __stream); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__nonnull__ (4))) size_t fread_unlocked (void * __restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) { size_t __sz = __builtin_dynamic_object_size (__ptr, 0); if (((__builtin_constant_p (__sz) && (__sz) == (long unsigned int) -1) || (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= ((__sz)) / ((__size)))) && (((long unsigned int) (__n)) <= ((__sz)) / ((__size)))))) { if (__builtin_constant_p (__size) && __builtin_constant_p (__n) && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2)) && __size * __n <= 8) { size_t __cnt = __size * __n; char *__cptr = (char *) __ptr; if (__cnt == 0) return 0; for (; __cnt > 0; --__cnt) { int __c = getc_unlocked (__stream); if (__c == (-1)) break; *__cptr++ = __c; } return (__cptr - (char *) __ptr) / __size; } return __fread_unlocked_alias (__ptr, __size, __n, __stream); } if ((((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <= (__sz) / (__size))) && !(((long unsigned int) (__n)) <= (__sz) / (__size)))) return __fread_unlocked_chk_warn (__ptr, __sz, __size, __n, __stream); return __fread_unlocked_chk (__ptr, __sz, __size, __n, __stream); } # 971 "/usr/include/stdio.h" 2 3 4 } # 48 "/usr/include/c++/15/cstdio" 2 3 # 98 "/usr/include/c++/15/cstdio" 3 namespace std { using ::FILE; using ::fpos_t; 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 ::printf; using ::putc; using ::putchar; 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; } # 159 "/usr/include/c++/15/cstdio" 3 namespace __gnu_cxx { # 177 "/usr/include/c++/15/cstdio" 3 using ::snprintf; using ::vfscanf; using ::vscanf; using ::vsnprintf; using ::vsscanf; } namespace std { using ::__gnu_cxx::snprintf; using ::__gnu_cxx::vfscanf; using ::__gnu_cxx::vscanf; using ::__gnu_cxx::vsnprintf; using ::__gnu_cxx::vsscanf; } # 48 "/usr/include/c++/15/ext/string_conversions.h" 2 3 # 1 "/usr/include/c++/15/cerrno" 1 3 # 47 "/usr/include/c++/15/cerrno" 3 # 1 "/usr/include/errno.h" 1 3 4 # 28 "/usr/include/errno.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/errno.h" 1 3 4 # 26 "/usr/include/riscv64-linux-gnu/bits/errno.h" 3 4 # 1 "/usr/include/linux/errno.h" 1 3 4 # 1 "/usr/include/riscv64-linux-gnu/asm/errno.h" 1 3 4 # 1 "/usr/include/asm-generic/errno.h" 1 3 4 # 1 "/usr/include/asm-generic/errno-base.h" 1 3 4 # 6 "/usr/include/asm-generic/errno.h" 2 3 4 # 2 "/usr/include/riscv64-linux-gnu/asm/errno.h" 2 3 4 # 2 "/usr/include/linux/errno.h" 2 3 4 # 27 "/usr/include/riscv64-linux-gnu/bits/errno.h" 2 3 4 # 29 "/usr/include/errno.h" 2 3 4 extern "C" { extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__)); extern char *program_invocation_name; extern char *program_invocation_short_name; # 1 "/usr/include/riscv64-linux-gnu/bits/types/error_t.h" 1 3 4 # 22 "/usr/include/riscv64-linux-gnu/bits/types/error_t.h" 3 4 typedef int error_t; # 49 "/usr/include/errno.h" 2 3 4 } # 48 "/usr/include/c++/15/cerrno" 2 3 # 49 "/usr/include/c++/15/ext/string_conversions.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template _Ret __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...), const char* __name, const _CharT* __str, std::size_t* __idx, _Base... __base) { _Ret __ret; _CharT* __endptr; struct _Save_errno { _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; } ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; } int _M_errno; } const __save_errno; struct _Range_chk { static bool _S_chk(_TRet, std::false_type) { return false; } static bool _S_chk(_TRet __val, std::true_type) { return __val < _TRet(__numeric_traits::__min) || __val > _TRet(__numeric_traits::__max); } }; const _TRet __tmp = __convf(__str, &__endptr, __base...); if (__endptr == __str) std::__throw_invalid_argument(__name); else if ((*__errno_location ()) == 34 || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{})) std::__throw_out_of_range(__name); else __ret = __tmp; if (__idx) *__idx = __endptr - __str; return __ret; } template _String __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*, __builtin_va_list), std::size_t __n, const _CharT* __fmt, ...) { _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n)); __builtin_va_list __args; __builtin_va_start(__args, __fmt); const int __len = __convf(__s, __n, __fmt, __args); __builtin_va_end(__args); return _String(__s, __s + __len); } } # 4445 "/usr/include/c++/15/bits/basic_string.h" 2 3 # 1 "/usr/include/c++/15/bits/charconv.h" 1 3 # 42 "/usr/include/c++/15/bits/charconv.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template constexpr bool __integer_to_chars_is_unsigned = ! __gnu_cxx::__int_traits<_Tp>::__is_signed; template constexpr unsigned __to_chars_len(_Tp __value, int __base = 10) noexcept { static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug"); unsigned __n = 1; const unsigned __b2 = __base * __base; const unsigned __b3 = __b2 * __base; const unsigned long __b4 = __b3 * __base; for (;;) { if (__value < (unsigned)__base) return __n; if (__value < __b2) return __n + 1; if (__value < __b3) return __n + 2; if (__value < __b4) return __n + 3; __value /= __b4; __n += 4; } } template void __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept { static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug"); constexpr char __digits[201] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"; unsigned __pos = __len - 1; while (__val >= 100) { auto const __num = (__val % 100) * 2; __val /= 100; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; __pos -= 2; } if (__val >= 10) { auto const __num = __val * 2; __first[1] = __digits[__num + 1]; __first[0] = __digits[__num]; } else __first[0] = '0' + __val; } } } # 4446 "/usr/include/c++/15/bits/basic_string.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { inline int stoi(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(), __idx, __base); } inline long stol(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), __idx, __base); } inline unsigned long stoul(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), __idx, __base); } inline long long stoll(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), __idx, __base); } inline unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), __idx, __base); } # 4488 "/usr/include/c++/15/bits/basic_string.h" 3 inline double stod(const string& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } inline float stof(const string& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } # 4516 "/usr/include/c++/15/bits/basic_string.h" 3 inline long double stold(const string& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } # 4528 "/usr/include/c++/15/bits/basic_string.h" 3 [[__nodiscard__]] inline string to_string(int __val) noexcept { const bool __neg = __val < 0; const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val; const auto __len = __detail::__to_chars_len(__uval); string __str; __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) { __p[0] = '-'; __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval); return __n; }); return __str; } [[__nodiscard__]] inline string to_string(unsigned __val) noexcept { const auto __len = __detail::__to_chars_len(__val); string __str; __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) { __detail::__to_chars_10_impl(__p, __n, __val); return __n; }); return __str; } [[__nodiscard__]] inline string to_string(long __val) { const bool __neg = __val < 0; const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val; const auto __len = __detail::__to_chars_len(__uval); string __str; __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) { __p[0] = '-'; __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval); return __n; }); return __str; } [[__nodiscard__]] inline string to_string(unsigned long __val) { const auto __len = __detail::__to_chars_len(__val); string __str; __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) { __detail::__to_chars_10_impl(__p, __n, __val); return __n; }); return __str; } [[__nodiscard__]] inline string to_string(long long __val) { const bool __neg = __val < 0; const unsigned long long __uval = __neg ? (unsigned long long)~__val + 1ull : __val; const auto __len = __detail::__to_chars_len(__uval); string __str; __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) { __p[0] = '-'; __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval); return __n; }); return __str; } [[__nodiscard__]] inline string to_string(unsigned long long __val) { const auto __len = __detail::__to_chars_len(__val); string __str; __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) { __detail::__to_chars_10_impl(__p, __n, __val); return __n; }); return __str; } # 4687 "/usr/include/c++/15/bits/basic_string.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wsuggest-attribute=format" [[__nodiscard__]] inline string to_string(float __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, "%f", __val); } [[__nodiscard__]] inline string to_string(double __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, "%f", __val); } [[__nodiscard__]] inline string to_string(long double __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, "%Lf", __val); } #pragma GCC diagnostic pop inline int stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(), __idx, __base); } inline long stol(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), __idx, __base); } inline unsigned long stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), __idx, __base); } inline long long stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), __idx, __base); } inline unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), __idx, __base); } inline float stof(const wstring& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } inline double stod(const wstring& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } inline long double stold(const wstring& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" inline void __to_wstring_numeric(const char* __s, int __len, wchar_t* __wout) { if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-' && wchar_t('.') == L'.' && wchar_t('e') == L'e') { for (int __i = 0; __i < __len; ++__i) __wout[__i] = (wchar_t) __s[__i]; } else { wchar_t __wc[256]; for (int __i = '0'; __i <= '9'; ++__i) __wc[__i] = L'0' + __i; __wc['.'] = L'.'; __wc['+'] = L'+'; __wc['-'] = L'-'; __wc['a'] = L'a'; __wc['b'] = L'b'; __wc['c'] = L'c'; __wc['d'] = L'd'; __wc['e'] = L'e'; __wc['f'] = L'f'; __wc['i'] = L'i'; __wc['n'] = L'n'; __wc['p'] = L'p'; __wc['x'] = L'x'; __wc['A'] = L'A'; __wc['B'] = L'B'; __wc['C'] = L'C'; __wc['D'] = L'D'; __wc['E'] = L'E'; __wc['F'] = L'F'; __wc['I'] = L'I'; __wc['N'] = L'N'; __wc['P'] = L'P'; __wc['X'] = L'X'; for (int __i = 0; __i < __len; ++__i) __wout[__i] = __wc[(int)__s[__i]]; } } inline wstring __to_wstring_numeric(string_view __s) { if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-' && wchar_t('.') == L'.' && wchar_t('e') == L'e') return wstring(__s.data(), __s.data() + __s.size()); else { wstring __ws; auto __f = __s.data(); __ws.__resize_and_overwrite(__s.size(), [__f] (wchar_t* __to, int __n) { std::__to_wstring_numeric(__f, __n, __to); return __n; }); return __ws; } } #pragma GCC diagnostic pop [[__nodiscard__]] inline wstring to_wstring(int __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(unsigned __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(long __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(unsigned long __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(long long __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(unsigned long long __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(float __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(double __val) { return std::__to_wstring_numeric(std::to_string(__val)); } [[__nodiscard__]] inline wstring to_wstring(long double __val) { return std::__to_wstring_numeric(std::to_string(__val)); } } } namespace std __attribute__ ((__visibility__ ("default"))) { template, _Alloc>> struct __str_hash_base : public __hash_base { [[__nodiscard__]] size_t operator()(const _StrT& __s) const noexcept { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); } }; template struct hash, _Alloc>> : public __str_hash_base { }; template struct hash, _Alloc>> : public __str_hash_base { }; template struct __is_fast_hash, _Alloc>>> : std::false_type { }; # 4944 "/usr/include/c++/15/bits/basic_string.h" 3 template struct hash, _Alloc>> : public __str_hash_base { }; template struct hash, _Alloc>> : public __str_hash_base { }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct __is_fast_hash> : std::false_type { }; # 4973 "/usr/include/c++/15/bits/basic_string.h" 3 inline namespace literals { inline namespace string_literals { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wliteral-suffix" __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char* __str, size_t __len) { return basic_string{__str, __len}; } __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const wchar_t* __str, size_t __len) { return basic_string{__str, __len}; } # 5003 "/usr/include/c++/15/bits/basic_string.h" 3 __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char16_t* __str, size_t __len) { return basic_string{__str, __len}; } __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char32_t* __str, size_t __len) { return basic_string{__str, __len}; } #pragma GCC diagnostic pop } } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : __and_< is_nothrow_move_constructible>, is_nothrow_move_assignable> >::type { }; } } # 57 "/usr/include/c++/15/string" 2 3 # 1 "/usr/include/c++/15/bits/basic_string.tcc" 1 3 # 46 "/usr/include/c++/15/bits/basic_string.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template const typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>::npos; template void basic_string<_CharT, _Traits, _Alloc>:: swap(basic_string& __s) noexcept { if (this == std::__addressof(__s)) return; _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator()); if (_M_is_local()) if (__s._M_is_local()) { if (length() && __s.length()) { _CharT __tmp_data[_S_local_capacity + 1]; traits_type::copy(__tmp_data, __s._M_local_buf, __s.length() + 1); traits_type::copy(__s._M_local_buf, _M_local_buf, length() + 1); traits_type::copy(_M_local_buf, __tmp_data, __s.length() + 1); } else if (__s.length()) { _M_init_local_buf(); traits_type::copy(_M_local_buf, __s._M_local_buf, __s.length() + 1); _M_length(__s.length()); __s._M_set_length(0); return; } else if (length()) { __s._M_init_local_buf(); traits_type::copy(__s._M_local_buf, _M_local_buf, length() + 1); __s._M_length(length()); _M_set_length(0); return; } } else { const size_type __tmp_capacity = __s._M_allocated_capacity; __s._M_init_local_buf(); traits_type::copy(__s._M_local_buf, _M_local_buf, length() + 1); _M_data(__s._M_data()); __s._M_data(__s._M_local_buf); _M_capacity(__tmp_capacity); } else { const size_type __tmp_capacity = _M_allocated_capacity; if (__s._M_is_local()) { _M_init_local_buf(); traits_type::copy(_M_local_buf, __s._M_local_buf, __s.length() + 1); __s._M_data(_M_data()); _M_data(_M_local_buf); } else { pointer __tmp_ptr = _M_data(); _M_data(__s._M_data()); __s._M_data(__tmp_ptr); _M_capacity(__s._M_allocated_capacity); } __s._M_capacity(__tmp_capacity); } const size_type __tmp_length = length(); _M_length(__s.length()); __s._M_length(__tmp_length); } template typename basic_string<_CharT, _Traits, _Alloc>::pointer basic_string<_CharT, _Traits, _Alloc>:: _M_create(size_type& __capacity, size_type __old_capacity) { if (__capacity > max_size()) std::__throw_length_error(("basic_string::_M_create")); if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) { __capacity = 2 * __old_capacity; if (__capacity > max_size()) __capacity = max_size(); } return _S_allocate(_M_get_allocator(), __capacity + 1); } template template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag) { size_type __len = 0; size_type __capacity = size_type(_S_local_capacity); _M_init_local_buf(); while (__beg != __end && __len < __capacity) { _M_local_buf[__len++] = *__beg; ++__beg; } struct _Guard { explicit _Guard(basic_string* __s) : _M_guarded(__s) { } ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } basic_string* _M_guarded; } __guard(this); while (__beg != __end) { if (__len == __capacity) { __capacity = __len + 1; pointer __another = _M_create(__capacity, __len); this->_S_copy(__another, _M_data(), __len); _M_dispose(); _M_data(__another); _M_capacity(__capacity); } traits_type::assign(_M_data()[__len++], static_cast<_CharT>(*__beg)); ++__beg; } __guard._M_guarded = 0; _M_set_length(__len); } template template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::forward_iterator_tag) { size_type __dnew = static_cast(std::distance(__beg, __end)); if (__dnew > size_type(_S_local_capacity)) { _M_data(_M_create(__dnew, size_type(0))); _M_capacity(__dnew); } else _M_init_local_buf(); struct _Guard { explicit _Guard(basic_string* __s) : _M_guarded(__s) { } ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } basic_string* _M_guarded; } __guard(this); this->_S_copy_chars(_M_data(), __beg, __end); __guard._M_guarded = 0; _M_set_length(__dnew); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(size_type __n, _CharT __c) { if (__n > size_type(_S_local_capacity)) { _M_data(_M_create(__n, size_type(0))); _M_capacity(__n); } else _M_init_local_buf(); if (__n) this->_S_assign(_M_data(), __n, __c); _M_set_length(__n); } template template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(const _CharT* __str, size_type __n) { if (__n > size_type(_S_local_capacity)) { _M_data(_M_create(__n, size_type(0))); _M_capacity(__n); } else _M_init_local_buf(); if (__n || _Terminated) this->_S_copy(_M_data(), __str, __n + _Terminated); _M_length(__n); if (!_Terminated) traits_type::assign(_M_data()[__n], _CharT()); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_assign(const basic_string& __str) { if (this != std::__addressof(__str)) { const size_type __rsize = __str.length(); const size_type __capacity = capacity(); if (__rsize > __capacity) { size_type __new_capacity = __rsize; pointer __tmp = _M_create(__new_capacity, __capacity); _M_dispose(); _M_data(__tmp); _M_capacity(__new_capacity); } if (__rsize) this->_S_copy(_M_data(), __str._M_data(), __rsize); _M_set_length(__rsize); } } template void basic_string<_CharT, _Traits, _Alloc>:: reserve(size_type __res) { const size_type __capacity = capacity(); if (__res <= __capacity) return; pointer __tmp = _M_create(__res, __capacity); this->_S_copy(__tmp, _M_data(), length() + 1); _M_dispose(); _M_data(__tmp); _M_capacity(__res); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, size_type __len2) { const size_type __how_much = length() - __pos - __len1; size_type __new_capacity = length() + __len2 - __len1; pointer __r = _M_create(__new_capacity, capacity()); if (__pos) this->_S_copy(__r, _M_data(), __pos); if (__s && __len2) this->_S_copy(__r + __pos, __s, __len2); if (__how_much) this->_S_copy(__r + __pos + __len2, _M_data() + __pos + __len1, __how_much); _M_dispose(); _M_data(__r); _M_capacity(__new_capacity); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_erase(size_type __pos, size_type __n) { const size_type __how_much = length() - __pos - __n; if (__how_much && __n) this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much); _M_set_length(length() - __n); } template void basic_string<_CharT, _Traits, _Alloc>:: reserve() { if (_M_is_local()) return; const size_type __length = length(); const size_type __capacity = _M_allocated_capacity; if (__length <= size_type(_S_local_capacity)) { _M_init_local_buf(); this->_S_copy(_M_local_buf, _M_data(), __length + 1); _M_destroy(__capacity); _M_data(_M_local_data()); } else if (__length < __capacity) try { pointer __tmp = _S_allocate(_M_get_allocator(), __length + 1); this->_S_copy(__tmp, _M_data(), __length + 1); _M_dispose(); _M_data(__tmp); _M_capacity(__length); } catch (const __cxxabiv1::__forced_unwind&) { throw; } catch (...) { } } template void basic_string<_CharT, _Traits, _Alloc>:: resize(size_type __n, _CharT __c) { const size_type __size = this->size(); if (__size < __n) this->append(__n - __size, __c); else if (__n < __size) this->_M_set_length(__n); } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_append(const _CharT* __s, size_type __n) { const size_type __len = __n + this->size(); if (__len <= this->capacity()) { if (__n) this->_S_copy(this->_M_data() + this->size(), __s, __n); } else this->_M_mutate(this->size(), size_type(0), __s, __n); this->_M_set_length(__len); return *this; } template template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2, std::__false_type) { const basic_string __s(__k1, __k2, this->get_allocator()); const size_type __n1 = __i2 - __i1; return _M_replace(__i1 - begin(), __n1, __s._M_data(), __s.size()); } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, _CharT __c) { _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); const size_type __old_size = this->size(); const size_type __new_size = __old_size + __n2 - __n1; if (__new_size <= this->capacity()) { pointer __p = this->_M_data() + __pos1; const size_type __how_much = __old_size - __pos1 - __n1; if (__how_much && __n1 != __n2) this->_S_move(__p + __n2, __p + __n1, __how_much); } else this->_M_mutate(__pos1, __n1, 0, __n2); if (__n2) this->_S_assign(this->_M_data() + __pos1, __n2, __c); this->_M_set_length(__new_size); return *this; } template __attribute__((__noinline__, __noclone__, __cold__)) void basic_string<_CharT, _Traits, _Alloc>:: _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s, const size_type __len2, const size_type __how_much) { if (__len2 && __len2 <= __len1) this->_S_move(__p, __s, __len2); if (__how_much && __len1 != __len2) this->_S_move(__p + __len2, __p + __len1, __how_much); if (__len2 > __len1) { if (__s + __len2 <= __p + __len1) this->_S_move(__p, __s, __len2); else if (__s >= __p + __len1) { const size_type __poff = (__s - __p) + (__len2 - __len1); this->_S_copy(__p, __p + __poff, __len2); } else { const size_type __nleft = (__p + __len1) - __s; this->_S_move(__p, __s, __nleft); this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft); } } } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace(size_type __pos, size_type __len1, const _CharT* __s, const size_type __len2) { _M_check_length(__len1, __len2, "basic_string::_M_replace"); const size_type __old_size = this->size(); const size_type __new_size = __old_size + __len2 - __len1; if (__new_size <= this->capacity()) { pointer __p = this->_M_data() + __pos; const size_type __how_much = __old_size - __pos - __len1; # 568 "/usr/include/c++/15/bits/basic_string.tcc" 3 if (__builtin_expect(_M_disjunct(__s), true)) { if (__how_much && __len1 != __len2) this->_S_move(__p + __len2, __p + __len1, __how_much); if (__len2) this->_S_copy(__p, __s, __len2); } else _M_replace_cold(__p, __len1, __s, __len2, __how_much); } else this->_M_mutate(__pos, __len1, __s, __len2); this->_M_set_length(__new_size); return *this; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: copy(_CharT* __s, size_type __n, size_type __pos) const { _M_check(__pos, "basic_string::copy"); __n = _M_limit(__pos, __n); ; if (__n) _S_copy(__s, _M_data() + __pos, __n); return __n; } # 611 "/usr/include/c++/15/bits/basic_string.tcc" 3 template template void basic_string<_CharT, _Traits, _Alloc>:: __resize_and_overwrite(const size_type __n, _Operation __op) { reserve(__n); _CharT* const __p = _M_data(); struct _Terminator { ~_Terminator() { _M_this->_M_set_length(_M_r); } basic_string* _M_this; size_type _M_r; }; _Terminator __term{this, 0}; auto __r = std::move(__op)(__p + 0, __n + 0); static_assert(__gnu_cxx::__is_integer_nonstrict::__value, "resize_and_overwrite operation must return an integer"); ; __term._M_r = size_type(__r); if (__term._M_r > __n) __builtin_unreachable(); } # 654 "/usr/include/c++/15/bits/basic_string.tcc" 3 template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find(const _CharT* __s, size_type __pos, size_type __n) const noexcept { ; const size_type __size = this->size(); if (__n == 0) return __pos <= __size ? __pos : npos; if (__pos >= __size) return npos; const _CharT __elem0 = __s[0]; const _CharT* const __data = data(); const _CharT* __first = __data + __pos; const _CharT* const __last = __data + __size; size_type __len = __size - __pos; while (__len >= __n) { __first = traits_type::find(__first, __len - __n + 1, __elem0); if (!__first) return npos; if (traits_type::compare(__first, __s, __n) == 0) return __first - __data; __len = __last - ++__first; } return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find(_CharT __c, size_type __pos) const noexcept { size_type __ret = npos; const size_type __size = this->size(); if (__pos < __size) { const _CharT* __data = _M_data(); const size_type __n = __size - __pos; const _CharT* __p = traits_type::find(__data + __pos, __n, __c); if (__p) __ret = __p - __data; } return __ret; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: rfind(const _CharT* __s, size_type __pos, size_type __n) const noexcept { ; const size_type __size = this->size(); if (__n <= __size) { __pos = std::min(size_type(__size - __n), __pos); const _CharT* __data = _M_data(); do { if (traits_type::compare(__data + __pos, __s, __n) == 0) return __pos; } while (__pos-- > 0); } return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: rfind(_CharT __c, size_type __pos) const noexcept { size_type __size = this->size(); if (__size) { if (--__size > __pos) __size = __pos; for (++__size; __size-- > 0; ) if (traits_type::eq(_M_data()[__size], __c)) return __size; } return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept { ; for (; __n && __pos < this->size(); ++__pos) { const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); if (__p) return __pos; } return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_last_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept { ; size_type __size = this->size(); if (__size && __n) { if (--__size > __pos) __size = __pos; do { if (traits_type::find(__s, __n, _M_data()[__size])) return __size; } while (__size-- != 0); } return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept { ; for (; __pos < this->size(); ++__pos) if (!traits_type::find(__s, __n, _M_data()[__pos])) return __pos; return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_not_of(_CharT __c, size_type __pos) const noexcept { for (; __pos < this->size(); ++__pos) if (!traits_type::eq(_M_data()[__pos], __c)) return __pos; return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept { ; size_type __size = this->size(); if (__size) { if (--__size > __pos) __size = __pos; do { if (!traits_type::find(__s, __n, _M_data()[__size])) return __size; } while (__size--); } return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_last_not_of(_CharT __c, size_type __pos) const noexcept { size_type __size = this->size(); if (__size) { if (--__size > __pos) __size = __pos; do { if (!traits_type::eq(_M_data()[__size], __c)) return __size; } while (__size--); } return npos; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, basic_string<_CharT, _Traits, _Alloc>& __str) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __istream_type::ios_base __ios_base; typedef typename __istream_type::int_type __int_type; typedef typename __string_type::size_type __size_type; typedef ctype<_CharT> __ctype_type; typedef typename __ctype_type::ctype_base __ctype_base; __size_type __extracted = 0; typename __ios_base::iostate __err = __ios_base::goodbit; typename __istream_type::sentry __cerb(__in, false); if (__cerb) { try { __str.erase(); _CharT __buf[128]; __size_type __len = 0; const streamsize __w = __in.width(); const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size(); const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); const __int_type __eof = _Traits::eof(); __int_type __c = __in.rdbuf()->sgetc(); while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) && !__ct.is(__ctype_base::space, _Traits::to_char_type(__c))) { if (__len == sizeof(__buf) / sizeof(_CharT)) { __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); __len = 0; } __buf[__len++] = _Traits::to_char_type(__c); ++__extracted; __c = __in.rdbuf()->snextc(); } __str.append(__buf, __len); if (__extracted < __n && _Traits::eq_int_type(__c, __eof)) __err |= __ios_base::eofbit; __in.width(0); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(__ios_base::badbit); throw; } catch(...) { __in._M_setstate(__ios_base::badbit); } } if (!__extracted) __err |= __ios_base::failbit; if (__err) __in.setstate(__err); return __in; } template basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __in, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __istream_type::ios_base __ios_base; typedef typename __istream_type::int_type __int_type; typedef typename __string_type::size_type __size_type; __size_type __extracted = 0; const __size_type __n = __str.max_size(); typename __ios_base::iostate __err = __ios_base::goodbit; typename __istream_type::sentry __cerb(__in, true); if (__cerb) { try { __str.erase(); const __int_type __idelim = _Traits::to_int_type(__delim); const __int_type __eof = _Traits::eof(); __int_type __c = __in.rdbuf()->sgetc(); while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) && !_Traits::eq_int_type(__c, __idelim)) { __str += _Traits::to_char_type(__c); ++__extracted; __c = __in.rdbuf()->snextc(); } if (_Traits::eq_int_type(__c, __eof)) __err |= __ios_base::eofbit; else if (_Traits::eq_int_type(__c, __idelim)) { ++__extracted; __in.rdbuf()->sbumpc(); } else __err |= __ios_base::failbit; } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(__ios_base::badbit); throw; } catch(...) { __in._M_setstate(__ios_base::badbit); } } if (!__extracted) __err |= __ios_base::failbit; if (__err) __in.setstate(__err); return __in; } # 1008 "/usr/include/c++/15/bits/basic_string.tcc" 3 extern template class basic_string; # 1021 "/usr/include/c++/15/bits/basic_string.tcc" 3 extern template basic_istream& operator>>(basic_istream&, string&); extern template basic_ostream& operator<<(basic_ostream&, const string&); extern template basic_istream& getline(basic_istream&, string&, char); extern template basic_istream& getline(basic_istream&, string&); extern template class basic_string; # 1047 "/usr/include/c++/15/bits/basic_string.tcc" 3 extern template basic_istream& operator>>(basic_istream&, wstring&); extern template basic_ostream& operator<<(basic_ostream&, const wstring&); extern template basic_istream& getline(basic_istream&, wstring&, wchar_t); extern template basic_istream& getline(basic_istream&, wstring&); } #pragma GCC diagnostic pop # 58 "/usr/include/c++/15/string" 2 3 # 69 "/usr/include/c++/15/string" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 70 "/usr/include/c++/15/string" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template> using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; using string = basic_string; using u16string = basic_string; using u32string = basic_string; using wstring = basic_string; } } # 43 "/usr/include/c++/15/bits/locale_classes.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 68 "/usr/include/c++/15/bits/locale_classes.h" 3 class locale { public: typedef int category; class facet; class id; class _Impl; friend class facet; friend class _Impl; template friend bool has_facet(const locale&) throw(); template friend const _Facet& use_facet(const locale&); template friend const _Facet* __try_use_facet(const locale&) noexcept; template friend struct __use_cache; # 108 "/usr/include/c++/15/bits/locale_classes.h" 3 static const category none = 0; static const category ctype = 1L << 0; static const category numeric = 1L << 1; static const category collate = 1L << 2; static const category time = 1L << 3; static const category monetary = 1L << 4; static const category messages = 1L << 5; static const category all = (ctype | numeric | collate | time | monetary | messages); # 127 "/usr/include/c++/15/bits/locale_classes.h" 3 locale() throw(); # 136 "/usr/include/c++/15/bits/locale_classes.h" 3 locale(const locale& __other) throw(); # 146 "/usr/include/c++/15/bits/locale_classes.h" 3 explicit locale(const char* __s); # 161 "/usr/include/c++/15/bits/locale_classes.h" 3 locale(const locale& __base, const char* __s, category __cat); # 172 "/usr/include/c++/15/bits/locale_classes.h" 3 explicit locale(const std::string& __s) : locale(__s.c_str()) { } # 187 "/usr/include/c++/15/bits/locale_classes.h" 3 locale(const locale& __base, const std::string& __s, category __cat) : locale(__base, __s.c_str(), __cat) { } # 202 "/usr/include/c++/15/bits/locale_classes.h" 3 locale(const locale& __base, const locale& __add, category __cat); # 215 "/usr/include/c++/15/bits/locale_classes.h" 3 template locale(const locale& __other, _Facet* __f); ~locale() throw(); # 229 "/usr/include/c++/15/bits/locale_classes.h" 3 const locale& operator=(const locale& __other) throw(); # 244 "/usr/include/c++/15/bits/locale_classes.h" 3 template [[__nodiscard__]] locale combine(const locale& __other) const; [[__nodiscard__]] __attribute ((__abi_tag__ ("cxx11"))) string name() const; # 275 "/usr/include/c++/15/bits/locale_classes.h" 3 [[__nodiscard__]] bool operator==(const locale& __other) const throw(); # 286 "/usr/include/c++/15/bits/locale_classes.h" 3 [[__nodiscard__]] bool operator!=(const locale& __other) const throw() { return !(this->operator==(__other)); } # 307 "/usr/include/c++/15/bits/locale_classes.h" 3 template [[__nodiscard__]] bool operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, const basic_string<_Char, _Traits, _Alloc>& __s2) const; # 324 "/usr/include/c++/15/bits/locale_classes.h" 3 static locale global(const locale& __loc); [[__nodiscard__]] static const locale& classic(); private: _Impl* _M_impl; static _Impl* _S_classic; static _Impl* _S_global; static const char* const* const _S_categories; # 360 "/usr/include/c++/15/bits/locale_classes.h" 3 enum { _S_categories_size = 6 + 6 }; static __gthread_once_t _S_once; explicit locale(_Impl*) throw(); static void _S_initialize(); static void _S_initialize_once() throw(); static category _S_normalize_category(category); void _M_coalesce(const locale& __base, const locale& __add, category __cat); static const id* const _S_twinned_facets[]; }; template constexpr bool __is_facet = is_base_of_v; template constexpr bool __is_facet = false; # 404 "/usr/include/c++/15/bits/locale_classes.h" 3 class locale::facet { private: friend class locale; friend class locale::_Impl; mutable _Atomic_word _M_refcount; static __c_locale _S_c_locale; static const char _S_c_name[2]; static __gthread_once_t _S_once; static void _S_initialize_once(); protected: # 435 "/usr/include/c++/15/bits/locale_classes.h" 3 explicit facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) { } virtual ~facet(); static void _S_create_c_locale(__c_locale& __cloc, const char* __s, __c_locale __old = 0); static __c_locale _S_clone_c_locale(__c_locale& __cloc) throw(); static void _S_destroy_c_locale(__c_locale& __cloc); static __c_locale _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s); static __c_locale _S_get_c_locale(); __attribute__ ((__const__)) static const char* _S_get_c_name() throw(); # 471 "/usr/include/c++/15/bits/locale_classes.h" 3 facet(const facet&) = delete; facet& operator=(const facet&) = delete; private: void _M_add_reference() const throw() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } void _M_remove_reference() const throw() { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) { ; try { delete this; } catch(...) { } } } const facet* _M_sso_shim(const id*) const; const facet* _M_cow_shim(const id*) const; protected: class __shim; }; # 516 "/usr/include/c++/15/bits/locale_classes.h" 3 class locale::id { private: friend class locale; friend class locale::_Impl; template friend const _Facet& use_facet(const locale&); template friend bool has_facet(const locale&) throw(); template friend const _Facet* __try_use_facet(const locale&) noexcept; mutable size_t _M_index; static _Atomic_word _S_refcount; void operator=(const id&); id(const id&); public: id() { } size_t _M_id() const throw(); }; class locale::_Impl { public: friend class locale; friend class locale::facet; template friend bool has_facet(const locale&) throw(); template friend const _Facet& use_facet(const locale&); template friend const _Facet* __try_use_facet(const locale&) noexcept; template friend struct __use_cache; private: _Atomic_word _M_refcount; const facet** _M_facets; size_t _M_facets_size; const facet** _M_caches; char** _M_names; static const locale::id* const _S_id_ctype[]; static const locale::id* const _S_id_numeric[]; static const locale::id* const _S_id_collate[]; static const locale::id* const _S_id_time[]; static const locale::id* const _S_id_monetary[]; static const locale::id* const _S_id_messages[]; static const locale::id* const* const _S_facet_categories[]; void _M_add_reference() throw() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } void _M_remove_reference() throw() { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) { ; try { delete this; } catch(...) { } } } _Impl(const _Impl&, size_t); _Impl(const char*, size_t); _Impl(size_t) throw(); ~_Impl() throw(); _Impl(const _Impl&); void operator=(const _Impl&); bool _M_check_same_name() { bool __ret = true; if (_M_names[1]) for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; return __ret; } void _M_replace_categories(const _Impl*, category); void _M_replace_category(const _Impl*, const locale::id* const*); void _M_replace_facet(const _Impl*, const locale::id*); void _M_install_facet(const locale::id*, const facet*); template void _M_init_facet(_Facet* __facet) { _M_install_facet(&_Facet::id, __facet); } template void _M_init_facet_unchecked(_Facet* __facet) { __facet->_M_add_reference(); _M_facets[_Facet::id._M_id()] = __facet; } void _M_install_cache(const facet*, size_t); void _M_init_extra(facet**); void _M_init_extra(void*, void*, const char*, const char*); }; # 686 "/usr/include/c++/15/bits/locale_classes.h" 3 template class __cxx11:: collate : public locale::facet { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; protected: __c_locale _M_c_locale_collate; public: static locale::id id; # 713 "/usr/include/c++/15/bits/locale_classes.h" 3 explicit collate(size_t __refs = 0) : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) { } # 727 "/usr/include/c++/15/bits/locale_classes.h" 3 explicit collate(__c_locale __cloc, size_t __refs = 0) : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) { } # 744 "/usr/include/c++/15/bits/locale_classes.h" 3 int compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } # 763 "/usr/include/c++/15/bits/locale_classes.h" 3 string_type transform(const _CharT* __lo, const _CharT* __hi) const { return this->do_transform(__lo, __hi); } # 777 "/usr/include/c++/15/bits/locale_classes.h" 3 long hash(const _CharT* __lo, const _CharT* __hi) const { return this->do_hash(__lo, __hi); } int _M_compare(const _CharT*, const _CharT*) const throw(); size_t _M_transform(_CharT*, const _CharT*, size_t) const throw(); protected: virtual ~collate() { _S_destroy_c_locale(_M_c_locale_collate); } # 806 "/usr/include/c++/15/bits/locale_classes.h" 3 virtual int do_compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const; # 820 "/usr/include/c++/15/bits/locale_classes.h" 3 virtual string_type do_transform(const _CharT* __lo, const _CharT* __hi) const; # 833 "/usr/include/c++/15/bits/locale_classes.h" 3 virtual long do_hash(const _CharT* __lo, const _CharT* __hi) const; }; template locale::id collate<_CharT>::id; template<> int collate::_M_compare(const char*, const char*) const throw(); template<> size_t collate::_M_transform(char*, const char*, size_t) const throw(); template<> int collate::_M_compare(const wchar_t*, const wchar_t*) const throw(); template<> size_t collate::_M_transform(wchar_t*, const wchar_t*, size_t) const throw(); template class __cxx11:: collate_byname : public collate<_CharT> { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; explicit collate_byname(const char* __s, size_t __refs = 0) : collate<_CharT>(__refs) { if (__builtin_strcmp(__s, "C") != 0 && __builtin_strcmp(__s, "POSIX") != 0) { this->_S_destroy_c_locale(this->_M_c_locale_collate); this->_S_create_c_locale(this->_M_c_locale_collate, __s); } } explicit collate_byname(const string& __s, size_t __refs = 0) : collate_byname(__s.c_str(), __refs) { } protected: virtual ~collate_byname() { } }; } # 1 "/usr/include/c++/15/bits/locale_classes.tcc" 1 3 # 43 "/usr/include/c++/15/bits/locale_classes.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" #pragma GCC diagnostic ignored "-Wvariadic-macros" namespace std __attribute__ ((__visibility__ ("default"))) { template locale:: locale(const locale& __other, _Facet* __f) { if (__builtin_expect(!__f, 0)) { _M_impl = __other._M_impl; _M_impl->_M_add_reference(); return; } _M_impl = new _Impl(*__other._M_impl, 1); try { _M_impl->_M_install_facet(&_Facet::id, __f); } catch(...) { _M_impl->_M_remove_reference(); throw; } delete [] _M_impl->_M_names[0]; _M_impl->_M_names[0] = 0; } template locale locale:: combine(const locale& __other) const { static_assert(__is_facet<_Facet>, "Template argument must be a facet"); _Impl* __tmp = new _Impl(*_M_impl, 1); try { __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); } catch(...) { __tmp->_M_remove_reference(); throw; } delete[] __tmp->_M_names[0]; __tmp->_M_names[0] = 0; return locale(__tmp); } template bool locale:: operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, const basic_string<_CharT, _Traits, _Alloc>& __s2) const { typedef std::collate<_CharT> __collate_type; const __collate_type& __collate = use_facet<__collate_type>(*this); return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), __s2.data(), __s2.data() + __s2.length()) < 0); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline const _Facet* __try_use_facet(const locale& __loc) noexcept { const size_t __i = _Facet::id._M_id(); const locale::facet** __facets = __loc._M_impl->_M_facets; if constexpr (__is_same(const _Facet, const ctype)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const num_get)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const num_put)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const codecvt)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const collate)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const moneypunct)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const moneypunct)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const money_get)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const money_put)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const numpunct)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const time_get)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const time_put)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const messages)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const ctype)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const num_get)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const num_put)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const codecvt)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const collate)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const moneypunct)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const moneypunct)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const money_get)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const money_put)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const numpunct)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const time_get)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const time_put)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const messages)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const codecvt)) return static_cast(__facets[__i]); if constexpr (__is_same(const _Facet, const codecvt)) return static_cast(__facets[__i]); if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) return 0; return dynamic_cast(__facets[__i]); } #pragma GCC diagnostic pop # 187 "/usr/include/c++/15/bits/locale_classes.tcc" 3 template [[__nodiscard__]] inline bool has_facet(const locale& __loc) noexcept { static_assert(__is_base_of(locale::facet, _Facet), "template argument must be derived from locale::facet"); return std::__try_use_facet<_Facet>(__loc) != 0; } # 215 "/usr/include/c++/15/bits/locale_classes.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdangling-reference" template [[__nodiscard__]] inline const _Facet& use_facet(const locale& __loc) { static_assert(__is_base_of(locale::facet, _Facet), "template argument must be derived from locale::facet"); if (const _Facet* __f = std::__try_use_facet<_Facet>(__loc)) return *__f; __throw_bad_cast(); } #pragma GCC diagnostic pop template int collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () { return 0; } template size_t collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () { return 0; } template int collate<_CharT>:: do_compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const { const string_type __one(__lo1, __hi1); const string_type __two(__lo2, __hi2); const _CharT* __p = __one.c_str(); const _CharT* __pend = __one.data() + __one.length(); const _CharT* __q = __two.c_str(); const _CharT* __qend = __two.data() + __two.length(); for (;;) { const int __res = _M_compare(__p, __q); if (__res) return __res; __p += char_traits<_CharT>::length(__p); __q += char_traits<_CharT>::length(__q); if (__p == __pend && __q == __qend) return 0; else if (__p == __pend) return -1; else if (__q == __qend) return 1; __p++; __q++; } } template typename collate<_CharT>::string_type collate<_CharT>:: do_transform(const _CharT* __lo, const _CharT* __hi) const { string_type __ret; const string_type __str(__lo, __hi); const _CharT* __p = __str.c_str(); const _CharT* __pend = __str.data() + __str.length(); size_t __len = (__hi - __lo) * 2; struct _Buf { _Buf(size_t __n, void* __buf, int __e) : _M_c(__buf ? (_CharT*)__buf : new _CharT[__n]), _M_stackbuf(__buf), _M_errno(__e) { } ~_Buf() { if (_M_c != _M_stackbuf) delete[] _M_c; if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; } void _M_realloc(size_t __len) { _CharT* __p = new _CharT[__len]; if (_M_c != _M_stackbuf) delete[] _M_c; _M_c = __p; } _CharT* _M_c; void* const _M_stackbuf; int _M_errno; }; const size_t __bytes = __len * sizeof(_CharT); _Buf __buf(__len, __bytes <= 256 ? __builtin_alloca(__bytes) : 0, (*__errno_location ())); (*__errno_location ()) = 0; for (;;) { size_t __res = _M_transform(__buf._M_c, __p, __len); if (__res >= __len) { if (__builtin_expect((*__errno_location ()), 0)) { __throw_system_error((*__errno_location ())); } __len = __res + 1; __buf._M_realloc(__len); __res = _M_transform(__buf._M_c, __p, __len); } __ret.append(__buf._M_c, __res); __p += char_traits<_CharT>::length(__p); if (__p == __pend) break; __p++; __ret.push_back(_CharT()); } return __ret; } template long collate<_CharT>:: do_hash(const _CharT* __lo, const _CharT* __hi) const { unsigned long __val = 0; for (; __lo < __hi; ++__lo) __val = *__lo + ((__val << 7) | (__val >> (__gnu_cxx::__numeric_traits:: __digits - 7))); return static_cast(__val); } extern template class collate; extern template class collate_byname; extern template const collate* __try_use_facet >(const locale&) noexcept; extern template const collate& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class collate; extern template class collate_byname; extern template const collate* __try_use_facet >(const locale&) noexcept; extern template const collate& use_facet >(const locale&); extern template bool has_facet >(const locale&); } #pragma GCC diagnostic pop # 897 "/usr/include/c++/15/bits/locale_classes.h" 2 3 # 44 "/usr/include/c++/15/bits/ios_base.h" 2 3 # 1 "/usr/include/c++/15/system_error" 1 3 # 43 "/usr/include/c++/15/system_error" 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/error_constants.h" 1 3 # 36 "/usr/include/riscv64-linux-gnu/c++/15/bits/error_constants.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum class errc { address_family_not_supported = 97, address_in_use = 98, address_not_available = 99, already_connected = 106, argument_list_too_long = 7, argument_out_of_domain = 33, bad_address = 14, bad_file_descriptor = 9, bad_message = 74, broken_pipe = 32, connection_aborted = 103, connection_already_in_progress = 114, connection_refused = 111, connection_reset = 104, cross_device_link = 18, destination_address_required = 89, device_or_resource_busy = 16, directory_not_empty = 39, executable_format_error = 8, file_exists = 17, file_too_large = 27, filename_too_long = 36, function_not_supported = 38, host_unreachable = 113, identifier_removed = 43, illegal_byte_sequence = 84, inappropriate_io_control_operation = 25, interrupted = 4, invalid_argument = 22, invalid_seek = 29, io_error = 5, is_a_directory = 21, message_size = 90, network_down = 100, network_reset = 102, network_unreachable = 101, no_buffer_space = 105, no_child_process = 10, no_link = 67, no_lock_available = 37, no_message_available = 61, no_message = 42, no_protocol_option = 92, no_space_on_device = 28, no_stream_resources = 63, 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 = 88, not_a_stream = 60, not_connected = 107, not_enough_memory = 12, not_supported = 95, operation_canceled = 125, operation_in_progress = 115, operation_not_permitted = 1, operation_not_supported = 95, operation_would_block = 11, owner_dead = 130, permission_denied = 13, protocol_error = 71, protocol_not_supported = 93, read_only_file_system = 30, resource_deadlock_would_occur = 35, resource_unavailable_try_again = 11, result_out_of_range = 34, state_not_recoverable = 131, stream_timeout = 62, text_file_busy = 26, timed_out = 110, too_many_files_open_in_system = 23, too_many_files_open = 24, too_many_links = 31, too_many_symbolic_link_levels = 40, value_too_large = 75, wrong_protocol_type = 91 }; } # 44 "/usr/include/c++/15/system_error" 2 3 # 1 "/usr/include/c++/15/stdexcept" 1 3 # 43 "/usr/include/c++/15/stdexcept" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __cow_string { union { const char* _M_p; char _M_bytes[sizeof(const char*)]; }; __cow_string(); __cow_string(const std::string&); __cow_string(const char*, size_t); __cow_string(const __cow_string&) noexcept; __cow_string& operator=(const __cow_string&) noexcept; ~__cow_string(); __cow_string(__cow_string&&) noexcept; __cow_string& operator=(__cow_string&&) noexcept; }; typedef basic_string __sso_string; # 115 "/usr/include/c++/15/stdexcept" 3 class logic_error : public exception { __cow_string _M_msg; public: explicit logic_error(const string& __arg) ; explicit logic_error(const char*) ; logic_error(logic_error&&) noexcept; logic_error& operator=(logic_error&&) noexcept; logic_error(const logic_error&) noexcept; logic_error& operator=(const logic_error&) noexcept; virtual ~logic_error() noexcept; virtual const char* what() const noexcept; }; class domain_error : public logic_error { public: explicit domain_error(const string& __arg) ; explicit domain_error(const char*) ; domain_error(const domain_error&) = default; domain_error& operator=(const domain_error&) = default; domain_error(domain_error&&) = default; domain_error& operator=(domain_error&&) = default; virtual ~domain_error() noexcept; }; class invalid_argument : public logic_error { public: explicit invalid_argument(const string& __arg) ; explicit invalid_argument(const char*) ; invalid_argument(const invalid_argument&) = default; invalid_argument& operator=(const invalid_argument&) = default; invalid_argument(invalid_argument&&) = default; invalid_argument& operator=(invalid_argument&&) = default; virtual ~invalid_argument() noexcept; }; class length_error : public logic_error { public: explicit length_error(const string& __arg) ; explicit length_error(const char*) ; length_error(const length_error&) = default; length_error& operator=(const length_error&) = default; length_error(length_error&&) = default; length_error& operator=(length_error&&) = default; virtual ~length_error() noexcept; }; class out_of_range : public logic_error { public: explicit out_of_range(const string& __arg) ; explicit out_of_range(const char*) ; out_of_range(const out_of_range&) = default; out_of_range& operator=(const out_of_range&) = default; out_of_range(out_of_range&&) = default; out_of_range& operator=(out_of_range&&) = default; virtual ~out_of_range() noexcept; }; class runtime_error : public exception { __cow_string _M_msg; public: explicit runtime_error(const string& __arg) ; explicit runtime_error(const char*) ; runtime_error(runtime_error&&) noexcept; runtime_error& operator=(runtime_error&&) noexcept; runtime_error(const runtime_error&) noexcept; runtime_error& operator=(const runtime_error&) noexcept; virtual ~runtime_error() noexcept; virtual const char* what() const noexcept; }; class range_error : public runtime_error { public: explicit range_error(const string& __arg) ; explicit range_error(const char*) ; range_error(const range_error&) = default; range_error& operator=(const range_error&) = default; range_error(range_error&&) = default; range_error& operator=(range_error&&) = default; virtual ~range_error() noexcept; }; class overflow_error : public runtime_error { public: explicit overflow_error(const string& __arg) ; explicit overflow_error(const char*) ; overflow_error(const overflow_error&) = default; overflow_error& operator=(const overflow_error&) = default; overflow_error(overflow_error&&) = default; overflow_error& operator=(overflow_error&&) = default; virtual ~overflow_error() noexcept; }; class underflow_error : public runtime_error { public: explicit underflow_error(const string& __arg) ; explicit underflow_error(const char*) ; underflow_error(const underflow_error&) = default; underflow_error& operator=(const underflow_error&) = default; underflow_error(underflow_error&&) = default; underflow_error& operator=(underflow_error&&) = default; virtual ~underflow_error() noexcept; }; } # 46 "/usr/include/c++/15/system_error" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { class error_code; class error_condition; class system_error; template struct is_error_code_enum : public false_type { }; template struct is_error_condition_enum : public false_type { }; template<> struct is_error_condition_enum : public true_type { }; template inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value; template inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; inline namespace _V2 { # 108 "/usr/include/c++/15/system_error" 3 class error_category { public: constexpr error_category() noexcept = default; virtual ~error_category(); error_category(const error_category&) = delete; error_category& operator=(const error_category&) = delete; virtual const char* name() const noexcept = 0; private: __attribute ((__abi_tag__ ("cxx11"))) virtual __cow_string _M_message(int) const; public: __attribute ((__abi_tag__ ("cxx11"))) virtual string message(int) const = 0; # 146 "/usr/include/c++/15/system_error" 3 public: virtual error_condition default_error_condition(int __i) const noexcept; virtual bool equivalent(int __i, const error_condition& __cond) const noexcept; virtual bool equivalent(const error_code& __code, int __i) const noexcept; [[__nodiscard__]] bool operator==(const error_category& __other) const noexcept { return this == &__other; } # 172 "/usr/include/c++/15/system_error" 3 bool operator<(const error_category& __other) const noexcept { return less()(this, &__other); } bool operator!=(const error_category& __other) const noexcept { return this != &__other; } }; [[__nodiscard__, __gnu__::__const__]] const error_category& generic_category() noexcept; [[__nodiscard__, __gnu__::__const__]] const error_category& system_category() noexcept; } namespace __adl_only { void make_error_code() = delete; void make_error_condition() = delete; } # 225 "/usr/include/c++/15/system_error" 3 class error_code { template using _Check = __enable_if_t::value>; public: error_code() noexcept : _M_value(0), _M_cat(&system_category()) { } error_code(int __v, const error_category& __cat) noexcept : _M_value(__v), _M_cat(&__cat) { } template> error_code(_ErrorCodeEnum __e) noexcept { using __adl_only::make_error_code; *this = make_error_code(__e); } error_code(const error_code&) = default; error_code& operator=(const error_code&) = default; void assign(int __v, const error_category& __cat) noexcept { _M_value = __v; _M_cat = &__cat; } void clear() noexcept { assign(0, system_category()); } [[__nodiscard__]] int value() const noexcept { return _M_value; } [[__nodiscard__]] const error_category& category() const noexcept { return *_M_cat; } error_condition default_error_condition() const noexcept; __attribute ((__abi_tag__ ("cxx11"))) string message() const { return category().message(value()); } [[__nodiscard__]] explicit operator bool() const noexcept { return _M_value != 0; } private: int _M_value; const error_category* _M_cat; }; # 302 "/usr/include/c++/15/system_error" 3 [[__nodiscard__]] inline error_code make_error_code(errc __e) noexcept { return error_code(static_cast(__e), generic_category()); } # 325 "/usr/include/c++/15/system_error" 3 inline bool operator<(const error_code& __lhs, const error_code& __rhs) noexcept { return (__lhs.category() < __rhs.category() || (__lhs.category() == __rhs.category() && __lhs.value() < __rhs.value())); } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) { return (__os << __e.category().name() << ':' << __e.value()); } # 356 "/usr/include/c++/15/system_error" 3 class error_condition { template using _Check = __enable_if_t::value>; public: error_condition() noexcept : _M_value(0), _M_cat(&generic_category()) { } error_condition(int __v, const error_category& __cat) noexcept : _M_value(__v), _M_cat(&__cat) { } template> error_condition(_ErrorConditionEnum __e) noexcept { using __adl_only::make_error_condition; *this = make_error_condition(__e); } error_condition(const error_condition&) = default; error_condition& operator=(const error_condition&) = default; void assign(int __v, const error_category& __cat) noexcept { _M_value = __v; _M_cat = &__cat; } void clear() noexcept { assign(0, generic_category()); } [[__nodiscard__]] int value() const noexcept { return _M_value; } [[__nodiscard__]] const error_category& category() const noexcept { return *_M_cat; } __attribute ((__abi_tag__ ("cxx11"))) string message() const { return category().message(value()); } [[__nodiscard__]] explicit operator bool() const noexcept { return _M_value != 0; } private: int _M_value; const error_category* _M_cat; }; # 435 "/usr/include/c++/15/system_error" 3 [[__nodiscard__]] inline error_condition make_error_condition(errc __e) noexcept { return error_condition(static_cast(__e), generic_category()); } # 449 "/usr/include/c++/15/system_error" 3 [[__nodiscard__]] inline bool operator==(const error_code& __lhs, const error_code& __rhs) noexcept { return __lhs.category() == __rhs.category() && __lhs.value() == __rhs.value(); } # 465 "/usr/include/c++/15/system_error" 3 [[__nodiscard__]] inline bool operator==(const error_code& __lhs, const error_condition& __rhs) noexcept { return __lhs.category().equivalent(__lhs.value(), __rhs) || __rhs.category().equivalent(__lhs, __rhs.value()); } # 480 "/usr/include/c++/15/system_error" 3 [[__nodiscard__]] inline bool operator==(const error_condition& __lhs, const error_condition& __rhs) noexcept { return __lhs.category() == __rhs.category() && __lhs.value() == __rhs.value(); } # 508 "/usr/include/c++/15/system_error" 3 inline bool operator<(const error_condition& __lhs, const error_condition& __rhs) noexcept { return (__lhs.category() < __rhs.category() || (__lhs.category() == __rhs.category() && __lhs.value() < __rhs.value())); } inline bool operator==(const error_condition& __lhs, const error_code& __rhs) noexcept { return (__rhs.category().equivalent(__rhs.value(), __lhs) || __lhs.category().equivalent(__rhs, __lhs.value())); } inline bool operator!=(const error_code& __lhs, const error_code& __rhs) noexcept { return !(__lhs == __rhs); } inline bool operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept { return !(__lhs == __rhs); } inline bool operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept { return !(__lhs == __rhs); } inline bool operator!=(const error_condition& __lhs, const error_condition& __rhs) noexcept { return !(__lhs == __rhs); } # 558 "/usr/include/c++/15/system_error" 3 class system_error : public std::runtime_error { private: error_code _M_code; public: system_error(error_code __ec = error_code()) : runtime_error(__ec.message()), _M_code(__ec) { } system_error(error_code __ec, const string& __what) : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } system_error(error_code __ec, const char* __what) : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } system_error(int __v, const error_category& __ecat, const char* __what) : system_error(error_code(__v, __ecat), __what) { } system_error(int __v, const error_category& __ecat) : runtime_error(error_code(__v, __ecat).message()), _M_code(__v, __ecat) { } system_error(int __v, const error_category& __ecat, const string& __what) : runtime_error(__what + (": " + error_code(__v, __ecat).message())), _M_code(__v, __ecat) { } system_error (const system_error &) = default; system_error &operator= (const system_error &) = default; virtual ~system_error() noexcept; const error_code& code() const noexcept { return _M_code; } }; } namespace std __attribute__ ((__visibility__ ("default"))) { template<> struct hash : public __hash_base { size_t operator()(const error_code& __e) const noexcept { const size_t __tmp = std::_Hash_impl::hash(__e.value()); return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); } }; template<> struct hash : public __hash_base { size_t operator()(const error_condition& __e) const noexcept { const size_t __tmp = std::_Hash_impl::hash(__e.value()); return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); } }; } # 49 "/usr/include/c++/15/bits/ios_base.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum _Ios_Fmtflags { _S_boolalpha = 1L << 0, _S_dec = 1L << 1, _S_fixed = 1L << 2, _S_hex = 1L << 3, _S_internal = 1L << 4, _S_left = 1L << 5, _S_oct = 1L << 6, _S_right = 1L << 7, _S_scientific = 1L << 8, _S_showbase = 1L << 9, _S_showpoint = 1L << 10, _S_showpos = 1L << 11, _S_skipws = 1L << 12, _S_unitbuf = 1L << 13, _S_uppercase = 1L << 14, _S_adjustfield = _S_left | _S_right | _S_internal, _S_basefield = _S_dec | _S_oct | _S_hex, _S_floatfield = _S_scientific | _S_fixed, _S_ios_fmtflags_end = 1L << 16, _S_ios_fmtflags_max = 0x7fffffff, _S_ios_fmtflags_min = ~0x7fffffff }; [[__nodiscard__]] constexpr inline _Ios_Fmtflags operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Fmtflags operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Fmtflags operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Fmtflags operator~(_Ios_Fmtflags __a) noexcept { return _Ios_Fmtflags(~static_cast(__a)); } constexpr inline const _Ios_Fmtflags& operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept { return __a = __a | __b; } constexpr inline const _Ios_Fmtflags& operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept { return __a = __a & __b; } constexpr inline const _Ios_Fmtflags& operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept { return __a = __a ^ __b; } # 127 "/usr/include/c++/15/bits/ios_base.h" 3 enum __attribute__((__flag_enum__)) _Ios_Openmode { _S_app = 1L << 0, _S_ate = 1L << 1, _S_bin = 1L << 2, _S_in = 1L << 3, _S_out = 1L << 4, _S_trunc = 1L << 5, _S_noreplace __attribute__((__unused__)) = 1L << 6, _S_ios_openmode_end __attribute__((__unused__)) = 1L << 16, _S_ios_openmode_max __attribute__((__unused__)) = 0x7fffffff, _S_ios_openmode_min __attribute__((__unused__)) = ~0x7fffffff }; [[__nodiscard__]] constexpr inline _Ios_Openmode operator&(_Ios_Openmode __a, _Ios_Openmode __b) noexcept { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Openmode operator|(_Ios_Openmode __a, _Ios_Openmode __b) noexcept { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Openmode operator^(_Ios_Openmode __a, _Ios_Openmode __b) noexcept { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Openmode operator~(_Ios_Openmode __a) noexcept { return _Ios_Openmode(~static_cast(__a)); } constexpr inline const _Ios_Openmode& operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept { return __a = __a | __b; } constexpr inline const _Ios_Openmode& operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept { return __a = __a & __b; } constexpr inline const _Ios_Openmode& operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept { return __a = __a ^ __b; } enum _Ios_Iostate { _S_goodbit = 0, _S_badbit = 1L << 0, _S_eofbit = 1L << 1, _S_failbit = 1L << 2, _S_ios_iostate_end = 1L << 16, _S_ios_iostate_max = 0x7fffffff, _S_ios_iostate_min = ~0x7fffffff }; [[__nodiscard__]] constexpr inline _Ios_Iostate operator&(_Ios_Iostate __a, _Ios_Iostate __b) noexcept { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Iostate operator|(_Ios_Iostate __a, _Ios_Iostate __b) noexcept { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Iostate operator^(_Ios_Iostate __a, _Ios_Iostate __b) noexcept { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } [[__nodiscard__]] constexpr inline _Ios_Iostate operator~(_Ios_Iostate __a) noexcept { return _Ios_Iostate(~static_cast(__a)); } constexpr inline const _Ios_Iostate& operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept { return __a = __a | __b; } constexpr inline const _Ios_Iostate& operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept { return __a = __a & __b; } constexpr inline const _Ios_Iostate& operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept { return __a = __a ^ __b; } enum _Ios_Seekdir { _S_beg = 0, _S_cur = 1, _S_end = 2, _S_ios_seekdir_end = 1L << 16 }; enum class io_errc { stream = 1 }; template <> struct is_error_code_enum : public true_type { }; [[__nodiscard__, __gnu__::__const__]] const error_category& iostream_category() noexcept; [[__nodiscard__]] inline error_code make_error_code(io_errc __e) noexcept { return error_code(static_cast(__e), iostream_category()); } [[__nodiscard__]] inline error_condition make_error_condition(io_errc __e) noexcept { return error_condition(static_cast(__e), iostream_category()); } # 265 "/usr/include/c++/15/bits/ios_base.h" 3 class ios_base { # 283 "/usr/include/c++/15/bits/ios_base.h" 3 public: # 292 "/usr/include/c++/15/bits/ios_base.h" 3 class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error { public: explicit failure(const string& __str); explicit failure(const string&, const error_code&); explicit failure(const char*, const error_code& = io_errc::stream); virtual ~failure() throw(); virtual const char* what() const throw(); }; # 378 "/usr/include/c++/15/bits/ios_base.h" 3 typedef _Ios_Fmtflags fmtflags; static const fmtflags boolalpha = _S_boolalpha; static const fmtflags dec = _S_dec; static const fmtflags fixed = _S_fixed; static const fmtflags hex = _S_hex; static const fmtflags internal = _S_internal; static const fmtflags left = _S_left; static const fmtflags oct = _S_oct; static const fmtflags right = _S_right; static const fmtflags scientific = _S_scientific; static const fmtflags showbase = _S_showbase; static const fmtflags showpoint = _S_showpoint; static const fmtflags showpos = _S_showpos; static const fmtflags skipws = _S_skipws; static const fmtflags unitbuf = _S_unitbuf; static const fmtflags uppercase = _S_uppercase; static const fmtflags adjustfield = _S_adjustfield; static const fmtflags basefield = _S_basefield; static const fmtflags floatfield = _S_floatfield; # 453 "/usr/include/c++/15/bits/ios_base.h" 3 typedef _Ios_Iostate iostate; static const iostate badbit = _S_badbit; static const iostate eofbit = _S_eofbit; static const iostate failbit = _S_failbit; static const iostate goodbit = _S_goodbit; # 484 "/usr/include/c++/15/bits/ios_base.h" 3 typedef _Ios_Openmode openmode; static const openmode app = _S_app; static const openmode ate = _S_ate; static const openmode binary = _S_bin; static const openmode in = _S_in; static const openmode out = _S_out; static const openmode trunc = _S_trunc; static const openmode __noreplace = _S_noreplace; # 523 "/usr/include/c++/15/bits/ios_base.h" 3 typedef _Ios_Seekdir seekdir; static const seekdir beg = _S_beg; static const seekdir cur = _S_cur; static const seekdir end = _S_end; # 556 "/usr/include/c++/15/bits/ios_base.h" 3 enum event { erase_event, imbue_event, copyfmt_event }; # 573 "/usr/include/c++/15/bits/ios_base.h" 3 typedef void (*event_callback) (event __e, ios_base& __b, int __i); # 585 "/usr/include/c++/15/bits/ios_base.h" 3 void register_callback(event_callback __fn, int __index); protected: streamsize _M_precision; streamsize _M_width; fmtflags _M_flags; iostate _M_exception; iostate _M_streambuf_state; struct _Callback_list { _Callback_list* _M_next; ios_base::event_callback _M_fn; int _M_index; _Atomic_word _M_refcount; _Callback_list(ios_base::event_callback __fn, int __index, _Callback_list* __cb) : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } void _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } int _M_remove_reference() { ; int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); if (__res == 0) { ; } return __res; } }; _Callback_list* _M_callbacks; void _M_call_callbacks(event __ev) throw(); void _M_dispose_callbacks(void) throw(); struct _Words { void* _M_pword; long _M_iword; _Words() : _M_pword(0), _M_iword(0) { } }; _Words _M_word_zero; enum { _S_local_word_size = 8 }; _Words _M_local_word[_S_local_word_size]; int _M_word_size; _Words* _M_word; _Words& _M_grow_words(int __index, bool __iword); locale _M_ios_locale; void _M_init() throw(); public: class Init { friend class ios_base; public: Init(); ~Init(); Init(const Init&) = default; Init& operator=(const Init&) = default; private: static _Atomic_word _S_refcount; static bool _S_synced_with_stdio; }; [[__nodiscard__]] fmtflags flags() const { return _M_flags; } # 704 "/usr/include/c++/15/bits/ios_base.h" 3 fmtflags flags(fmtflags __fmtfl) { fmtflags __old = _M_flags; _M_flags = __fmtfl; return __old; } # 720 "/usr/include/c++/15/bits/ios_base.h" 3 fmtflags setf(fmtflags __fmtfl) { fmtflags __old = _M_flags; _M_flags |= __fmtfl; return __old; } # 737 "/usr/include/c++/15/bits/ios_base.h" 3 fmtflags setf(fmtflags __fmtfl, fmtflags __mask) { fmtflags __old = _M_flags; _M_flags &= ~__mask; _M_flags |= (__fmtfl & __mask); return __old; } void unsetf(fmtflags __mask) { _M_flags &= ~__mask; } # 763 "/usr/include/c++/15/bits/ios_base.h" 3 [[__nodiscard__]] streamsize precision() const { return _M_precision; } streamsize precision(streamsize __prec) { streamsize __old = _M_precision; _M_precision = __prec; return __old; } [[__nodiscard__]] streamsize width() const { return _M_width; } streamsize width(streamsize __wide) { streamsize __old = _M_width; _M_width = __wide; return __old; } # 816 "/usr/include/c++/15/bits/ios_base.h" 3 static bool sync_with_stdio(bool __sync = true); # 828 "/usr/include/c++/15/bits/ios_base.h" 3 locale imbue(const locale& __loc) throw(); # 839 "/usr/include/c++/15/bits/ios_base.h" 3 [[__nodiscard__]] locale getloc() const { return _M_ios_locale; } # 851 "/usr/include/c++/15/bits/ios_base.h" 3 const locale& _M_getloc() const { return _M_ios_locale; } # 870 "/usr/include/c++/15/bits/ios_base.h" 3 static int xalloc() throw(); # 886 "/usr/include/c++/15/bits/ios_base.h" 3 long& iword(int __ix) { _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size) ? _M_word[__ix] : _M_grow_words(__ix, true); return __word._M_iword; } # 907 "/usr/include/c++/15/bits/ios_base.h" 3 void*& pword(int __ix) { _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size) ? _M_word[__ix] : _M_grow_words(__ix, false); return __word._M_pword; } # 924 "/usr/include/c++/15/bits/ios_base.h" 3 virtual ~ios_base(); protected: ios_base() throw (); # 938 "/usr/include/c++/15/bits/ios_base.h" 3 public: ios_base(const ios_base&) = delete; ios_base& operator=(const ios_base&) = delete; protected: void _M_move(ios_base&) noexcept; void _M_swap(ios_base& __rhs) noexcept; }; inline ios_base& boolalpha(ios_base& __base) { __base.setf(ios_base::boolalpha); return __base; } inline ios_base& noboolalpha(ios_base& __base) { __base.unsetf(ios_base::boolalpha); return __base; } inline ios_base& showbase(ios_base& __base) { __base.setf(ios_base::showbase); return __base; } inline ios_base& noshowbase(ios_base& __base) { __base.unsetf(ios_base::showbase); return __base; } inline ios_base& showpoint(ios_base& __base) { __base.setf(ios_base::showpoint); return __base; } inline ios_base& noshowpoint(ios_base& __base) { __base.unsetf(ios_base::showpoint); return __base; } inline ios_base& showpos(ios_base& __base) { __base.setf(ios_base::showpos); return __base; } inline ios_base& noshowpos(ios_base& __base) { __base.unsetf(ios_base::showpos); return __base; } inline ios_base& skipws(ios_base& __base) { __base.setf(ios_base::skipws); return __base; } inline ios_base& noskipws(ios_base& __base) { __base.unsetf(ios_base::skipws); return __base; } inline ios_base& uppercase(ios_base& __base) { __base.setf(ios_base::uppercase); return __base; } inline ios_base& nouppercase(ios_base& __base) { __base.unsetf(ios_base::uppercase); return __base; } inline ios_base& unitbuf(ios_base& __base) { __base.setf(ios_base::unitbuf); return __base; } inline ios_base& nounitbuf(ios_base& __base) { __base.unsetf(ios_base::unitbuf); return __base; } inline ios_base& internal(ios_base& __base) { __base.setf(ios_base::internal, ios_base::adjustfield); return __base; } inline ios_base& left(ios_base& __base) { __base.setf(ios_base::left, ios_base::adjustfield); return __base; } inline ios_base& right(ios_base& __base) { __base.setf(ios_base::right, ios_base::adjustfield); return __base; } inline ios_base& dec(ios_base& __base) { __base.setf(ios_base::dec, ios_base::basefield); return __base; } inline ios_base& hex(ios_base& __base) { __base.setf(ios_base::hex, ios_base::basefield); return __base; } inline ios_base& oct(ios_base& __base) { __base.setf(ios_base::oct, ios_base::basefield); return __base; } inline ios_base& fixed(ios_base& __base) { __base.setf(ios_base::fixed, ios_base::floatfield); return __base; } inline ios_base& scientific(ios_base& __base) { __base.setf(ios_base::scientific, ios_base::floatfield); return __base; } inline ios_base& hexfloat(ios_base& __base) { __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); return __base; } inline ios_base& defaultfloat(ios_base& __base) { __base.unsetf(ios_base::floatfield); return __base; } } # 47 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/streambuf" 1 3 # 49 "/usr/include/c++/15/streambuf" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, basic_streambuf<_CharT, _Traits>*, bool&); # 125 "/usr/include/c++/15/streambuf" 3 template class basic_streambuf { public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_streambuf __streambuf_type; friend class basic_ios; friend class basic_istream; friend class basic_ostream; friend class istreambuf_iterator; friend class ostreambuf_iterator; friend streamsize __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, _CharT2*>::__type __copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, _CharT2*); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, const _CharT2&); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, void>::__type advance(istreambuf_iterator<_CharT2>&, _Distance); friend void __istream_extract(istream&, char*, streamsize); template friend basic_istream<_CharT2, _Traits2>& operator>>(basic_istream<_CharT2, _Traits2>&, basic_string<_CharT2, _Traits2, _Alloc>&); template friend basic_istream<_CharT2, _Traits2>& getline(basic_istream<_CharT2, _Traits2>&, basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); protected: char_type* _M_in_beg; char_type* _M_in_cur; char_type* _M_in_end; char_type* _M_out_beg; char_type* _M_out_cur; char_type* _M_out_end; locale _M_buf_locale; public: virtual ~basic_streambuf() { } # 217 "/usr/include/c++/15/streambuf" 3 locale pubimbue(const locale& __loc) { locale __tmp(this->getloc()); this->imbue(__loc); _M_buf_locale = __loc; return __tmp; } # 234 "/usr/include/c++/15/streambuf" 3 locale getloc() const { return _M_buf_locale; } # 247 "/usr/include/c++/15/streambuf" 3 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) { return this->setbuf(__s, __n); } # 259 "/usr/include/c++/15/streambuf" 3 pos_type pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out) { return this->seekoff(__off, __way, __mode); } # 271 "/usr/include/c++/15/streambuf" 3 pos_type pubseekpos(pos_type __sp, ios_base::openmode __mode = ios_base::in | ios_base::out) { return this->seekpos(__sp, __mode); } int pubsync() { return this->sync(); } # 292 "/usr/include/c++/15/streambuf" 3 streamsize in_avail() { const streamsize __ret = this->egptr() - this->gptr(); return __ret ? __ret : this->showmanyc(); } # 306 "/usr/include/c++/15/streambuf" 3 int_type snextc() { int_type __ret = traits_type::eof(); if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), __ret), true)) __ret = this->sgetc(); return __ret; } # 324 "/usr/include/c++/15/streambuf" 3 int_type sbumpc() { int_type __ret; if (__builtin_expect(this->gptr() < this->egptr(), true)) { __ret = traits_type::to_int_type(*this->gptr()); this->gbump(1); } else __ret = this->uflow(); return __ret; } # 346 "/usr/include/c++/15/streambuf" 3 int_type sgetc() { int_type __ret; if (__builtin_expect(this->gptr() < this->egptr(), true)) __ret = traits_type::to_int_type(*this->gptr()); else __ret = this->underflow(); return __ret; } # 365 "/usr/include/c++/15/streambuf" 3 streamsize sgetn(char_type* __s, streamsize __n) { return this->xsgetn(__s, __n); } # 380 "/usr/include/c++/15/streambuf" 3 int_type sputbackc(char_type __c) { int_type __ret; const bool __testpos = this->eback() < this->gptr(); if (__builtin_expect(!__testpos || !traits_type::eq(__c, this->gptr()[-1]), false)) __ret = this->pbackfail(traits_type::to_int_type(__c)); else { this->gbump(-1); __ret = traits_type::to_int_type(*this->gptr()); } return __ret; } # 405 "/usr/include/c++/15/streambuf" 3 int_type sungetc() { int_type __ret; if (__builtin_expect(this->eback() < this->gptr(), true)) { this->gbump(-1); __ret = traits_type::to_int_type(*this->gptr()); } else __ret = this->pbackfail(); return __ret; } # 432 "/usr/include/c++/15/streambuf" 3 int_type sputc(char_type __c) { int_type __ret; if (__builtin_expect(this->pptr() < this->epptr(), true)) { *this->pptr() = __c; this->pbump(1); __ret = traits_type::to_int_type(__c); } else __ret = this->overflow(traits_type::to_int_type(__c)); return __ret; } # 458 "/usr/include/c++/15/streambuf" 3 streamsize sputn(const char_type* __s, streamsize __n) { return this->xsputn(__s, __n); } protected: # 472 "/usr/include/c++/15/streambuf" 3 basic_streambuf() : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), _M_out_beg(0), _M_out_cur(0), _M_out_end(0), _M_buf_locale(locale()) { } # 490 "/usr/include/c++/15/streambuf" 3 char_type* eback() const { return _M_in_beg; } char_type* gptr() const { return _M_in_cur; } char_type* egptr() const { return _M_in_end; } # 506 "/usr/include/c++/15/streambuf" 3 void gbump(int __n) { _M_in_cur += __n; } # 517 "/usr/include/c++/15/streambuf" 3 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) { _M_in_beg = __gbeg; _M_in_cur = __gnext; _M_in_end = __gend; } # 537 "/usr/include/c++/15/streambuf" 3 char_type* pbase() const { return _M_out_beg; } char_type* pptr() const { return _M_out_cur; } char_type* epptr() const { return _M_out_end; } # 553 "/usr/include/c++/15/streambuf" 3 void pbump(int __n) { _M_out_cur += __n; } # 563 "/usr/include/c++/15/streambuf" 3 void setp(char_type* __pbeg, char_type* __pend) { _M_out_beg = _M_out_cur = __pbeg; _M_out_end = __pend; } # 584 "/usr/include/c++/15/streambuf" 3 virtual void imbue(const locale& __loc __attribute__ ((__unused__))) { } # 599 "/usr/include/c++/15/streambuf" 3 virtual basic_streambuf* setbuf(char_type*, streamsize) { return this; } # 610 "/usr/include/c++/15/streambuf" 3 virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out) { return pos_type(off_type(-1)); } # 622 "/usr/include/c++/15/streambuf" 3 virtual pos_type seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out) { return pos_type(off_type(-1)); } # 635 "/usr/include/c++/15/streambuf" 3 virtual int sync() { return 0; } # 657 "/usr/include/c++/15/streambuf" 3 virtual streamsize showmanyc() { return 0; } # 673 "/usr/include/c++/15/streambuf" 3 virtual streamsize xsgetn(char_type* __s, streamsize __n); # 695 "/usr/include/c++/15/streambuf" 3 virtual int_type underflow() { return traits_type::eof(); } # 708 "/usr/include/c++/15/streambuf" 3 virtual int_type uflow() { int_type __ret = traits_type::eof(); const bool __testeof = traits_type::eq_int_type(this->underflow(), __ret); if (!__testeof) { __ret = traits_type::to_int_type(*this->gptr()); this->gbump(1); } return __ret; } # 732 "/usr/include/c++/15/streambuf" 3 virtual int_type pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) { return traits_type::eof(); } # 750 "/usr/include/c++/15/streambuf" 3 virtual streamsize xsputn(const char_type* __s, streamsize __n); # 776 "/usr/include/c++/15/streambuf" 3 virtual int_type overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) { return traits_type::eof(); } # 803 "/usr/include/c++/15/streambuf" 3 void __safe_gbump(streamsize __n) { _M_in_cur += __n; } void __safe_pbump(streamsize __n) { _M_out_cur += __n; } protected: basic_streambuf(const basic_streambuf&); basic_streambuf& operator=(const basic_streambuf&); void swap(basic_streambuf& __sb) { std::swap(_M_in_beg, __sb._M_in_beg); std::swap(_M_in_cur, __sb._M_in_cur); std::swap(_M_in_end, __sb._M_in_end); std::swap(_M_out_beg, __sb._M_out_beg); std::swap(_M_out_cur, __sb._M_out_cur); std::swap(_M_out_end, __sb._M_out_end); std::swap(_M_buf_locale, __sb._M_buf_locale); } }; template std::basic_streambuf<_CharT, _Traits>:: basic_streambuf(const basic_streambuf&) = default; template std::basic_streambuf<_CharT, _Traits>& std::basic_streambuf<_CharT, _Traits>:: operator=(const basic_streambuf&) = default; template<> streamsize __copy_streambufs_eof(basic_streambuf* __sbin, basic_streambuf* __sbout, bool& __ineof); template<> streamsize __copy_streambufs_eof(basic_streambuf* __sbin, basic_streambuf* __sbout, bool& __ineof); } # 1 "/usr/include/c++/15/bits/streambuf.tcc" 1 3 # 41 "/usr/include/c++/15/bits/streambuf.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template streamsize basic_streambuf<_CharT, _Traits>:: xsgetn(char_type* __s, streamsize __n) { streamsize __ret = 0; while (__ret < __n) { const streamsize __buf_len = this->egptr() - this->gptr(); if (__buf_len) { const streamsize __remaining = __n - __ret; const streamsize __len = std::min(__buf_len, __remaining); traits_type::copy(__s, this->gptr(), __len); __ret += __len; __s += __len; this->__safe_gbump(__len); } if (__ret < __n) { const int_type __c = this->uflow(); if (!traits_type::eq_int_type(__c, traits_type::eof())) { traits_type::assign(*__s++, traits_type::to_char_type(__c)); ++__ret; } else break; } } return __ret; } template streamsize basic_streambuf<_CharT, _Traits>:: xsputn(const char_type* __s, streamsize __n) { streamsize __ret = 0; while (__ret < __n) { const streamsize __buf_len = this->epptr() - this->pptr(); if (__buf_len) { const streamsize __remaining = __n - __ret; const streamsize __len = std::min(__buf_len, __remaining); traits_type::copy(this->pptr(), __s, __len); __ret += __len; __s += __len; this->__safe_pbump(__len); } if (__ret < __n) { int_type __c = this->overflow(traits_type::to_int_type(*__s)); if (!traits_type::eq_int_type(__c, traits_type::eof())) { ++__ret; ++__s; } else break; } } return __ret; } template streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, basic_streambuf<_CharT, _Traits>* __sbout, bool& __ineof) { streamsize __ret = 0; __ineof = true; typename _Traits::int_type __c = __sbin->sgetc(); while (!_Traits::eq_int_type(__c, _Traits::eof())) { __c = __sbout->sputc(_Traits::to_char_type(__c)); if (_Traits::eq_int_type(__c, _Traits::eof())) { __ineof = false; break; } ++__ret; __c = __sbin->snextc(); } return __ret; } template inline streamsize __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, basic_streambuf<_CharT, _Traits>* __sbout) { bool __ineof; return __copy_streambufs_eof(__sbin, __sbout, __ineof); } extern template class basic_streambuf; extern template streamsize __copy_streambufs(basic_streambuf*, basic_streambuf*); extern template class basic_streambuf; extern template streamsize __copy_streambufs(basic_streambuf*, basic_streambuf*); } #pragma GCC diagnostic pop # 863 "/usr/include/c++/15/streambuf" 2 3 # 48 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/bits/basic_ios.h" 1 3 # 39 "/usr/include/c++/15/bits/basic_ios.h" 3 # 1 "/usr/include/c++/15/bits/locale_facets.h" 1 3 # 41 "/usr/include/c++/15/bits/locale_facets.h" 3 # 1 "/usr/include/c++/15/cwctype" 1 3 # 55 "/usr/include/c++/15/cwctype" 3 # 1 "/usr/include/wctype.h" 1 3 4 # 38 "/usr/include/wctype.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/wctype-wchar.h" 1 3 4 # 38 "/usr/include/riscv64-linux-gnu/bits/wctype-wchar.h" 3 4 typedef unsigned long int wctype_t; # 56 "/usr/include/riscv64-linux-gnu/bits/wctype-wchar.h" 3 4 enum { __ISwupper = 0, __ISwlower = 1, __ISwalpha = 2, __ISwdigit = 3, __ISwxdigit = 4, __ISwspace = 5, __ISwprint = 6, __ISwgraph = 7, __ISwblank = 8, __ISwcntrl = 9, __ISwpunct = 10, __ISwalnum = 11, _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))), _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) }; extern "C" { extern int iswalnum (wint_t __wc) noexcept (true); extern int iswalpha (wint_t __wc) noexcept (true); extern int iswcntrl (wint_t __wc) noexcept (true); extern int iswdigit (wint_t __wc) noexcept (true); extern int iswgraph (wint_t __wc) noexcept (true); extern int iswlower (wint_t __wc) noexcept (true); extern int iswprint (wint_t __wc) noexcept (true); extern int iswpunct (wint_t __wc) noexcept (true); extern int iswspace (wint_t __wc) noexcept (true); extern int iswupper (wint_t __wc) noexcept (true); extern int iswxdigit (wint_t __wc) noexcept (true); extern int iswblank (wint_t __wc) noexcept (true); # 155 "/usr/include/riscv64-linux-gnu/bits/wctype-wchar.h" 3 4 extern wctype_t wctype (const char *__property) noexcept (true); extern int iswctype (wint_t __wc, wctype_t __desc) noexcept (true); extern wint_t towlower (wint_t __wc) noexcept (true); extern wint_t towupper (wint_t __wc) noexcept (true); } # 39 "/usr/include/wctype.h" 2 3 4 extern "C" { typedef const __int32_t *wctrans_t; extern wctrans_t wctrans (const char *__property) noexcept (true); extern wint_t towctrans (wint_t __wc, wctrans_t __desc) noexcept (true); extern int iswalnum_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswalpha_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswcntrl_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswdigit_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswgraph_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswlower_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswprint_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswpunct_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswspace_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswupper_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswxdigit_l (wint_t __wc, locale_t __locale) noexcept (true); extern int iswblank_l (wint_t __wc, locale_t __locale) noexcept (true); extern wctype_t wctype_l (const char *__property, locale_t __locale) noexcept (true); extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) noexcept (true); extern wint_t towlower_l (wint_t __wc, locale_t __locale) noexcept (true); extern wint_t towupper_l (wint_t __wc, locale_t __locale) noexcept (true); extern wctrans_t wctrans_l (const char *__property, locale_t __locale) noexcept (true); extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, locale_t __locale) noexcept (true); } # 56 "/usr/include/c++/15/cwctype" 2 3 # 82 "/usr/include/c++/15/cwctype" 3 namespace std { using ::wctrans_t; using ::wctype_t; using ::wint_t; using ::iswalnum; using ::iswalpha; using ::iswblank; using ::iswcntrl; using ::iswctype; using ::iswdigit; using ::iswgraph; using ::iswlower; using ::iswprint; using ::iswpunct; using ::iswspace; using ::iswupper; using ::iswxdigit; using ::towctrans; using ::towlower; using ::towupper; using ::wctrans; using ::wctype; } # 42 "/usr/include/c++/15/bits/locale_facets.h" 2 3 # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/ctype_base.h" 1 3 # 36 "/usr/include/riscv64-linux-gnu/c++/15/bits/ctype_base.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct ctype_base { typedef const int* __to_type; typedef unsigned short mask; static const mask upper = _ISupper; static const mask lower = _ISlower; static const mask alpha = _ISalpha; static const mask digit = _ISdigit; static const mask xdigit = _ISxdigit; static const mask space = _ISspace; static const mask print = _ISprint; static const mask graph = _ISalpha | _ISdigit | _ISpunct; static const mask cntrl = _IScntrl; static const mask punct = _ISpunct; static const mask alnum = _ISalpha | _ISdigit; static const mask blank = _ISblank; }; } # 44 "/usr/include/c++/15/bits/locale_facets.h" 2 3 # 1 "/usr/include/c++/15/bits/streambuf_iterator.h" 1 3 # 41 "/usr/include/c++/15/bits/streambuf_iterator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 51 "/usr/include/c++/15/bits/streambuf_iterator.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template class istreambuf_iterator : public iterator { public: # 72 "/usr/include/c++/15/bits/streambuf_iterator.h" 3 typedef _CharT char_type; typedef _Traits traits_type; typedef typename _Traits::int_type int_type; typedef basic_streambuf<_CharT, _Traits> streambuf_type; typedef basic_istream<_CharT, _Traits> istream_type; template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, ostreambuf_iterator<_CharT2> >::__type copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, ostreambuf_iterator<_CharT2>); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, _CharT2*>::__type __copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, _CharT2*); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, _CharT2*>::__type __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, const _CharT2&); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, void>::__type advance(istreambuf_iterator<_CharT2>&, _Distance); private: mutable streambuf_type* _M_sbuf; int_type _M_c; public: constexpr istreambuf_iterator() noexcept : _M_sbuf(0), _M_c(traits_type::eof()) { } istreambuf_iterator(const istreambuf_iterator&) noexcept = default; ~istreambuf_iterator() = default; istreambuf_iterator(istream_type& __s) noexcept : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } istreambuf_iterator(streambuf_type* __s) noexcept : _M_sbuf(__s), _M_c(traits_type::eof()) { } istreambuf_iterator& operator=(const istreambuf_iterator&) noexcept = default; [[__nodiscard__]] char_type operator*() const { int_type __c = _M_get(); # 163 "/usr/include/c++/15/bits/streambuf_iterator.h" 3 return traits_type::to_char_type(__c); } istreambuf_iterator& operator++() { ; _M_sbuf->sbumpc(); _M_c = traits_type::eof(); return *this; } istreambuf_iterator operator++(int) { ; istreambuf_iterator __old = *this; __old._M_c = _M_sbuf->sbumpc(); _M_c = traits_type::eof(); return __old; } [[__nodiscard__]] bool equal(const istreambuf_iterator& __b) const { return _M_at_eof() == __b._M_at_eof(); } private: int_type _M_get() const { int_type __ret = _M_c; if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc())) _M_sbuf = 0; return __ret; } bool _M_at_eof() const { return _S_is_eof(_M_get()); } static bool _S_is_eof(int_type __c) { const int_type __eof = traits_type::eof(); return traits_type::eq_int_type(__c, __eof); } }; template [[__nodiscard__]] inline bool operator==(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) { return __a.equal(__b); } template [[__nodiscard__]] inline bool operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) { return !__a.equal(__b); } template class ostreambuf_iterator : public iterator { public: typedef _CharT char_type; typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> streambuf_type; typedef basic_ostream<_CharT, _Traits> ostream_type; template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, ostreambuf_iterator<_CharT2> >::__type copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, ostreambuf_iterator<_CharT2>); private: streambuf_type* _M_sbuf; bool _M_failed; public: # 286 "/usr/include/c++/15/bits/streambuf_iterator.h" 3 ostreambuf_iterator(ostream_type& __s) noexcept : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } ostreambuf_iterator(streambuf_type* __s) noexcept : _M_sbuf(__s), _M_failed(!_M_sbuf) { } ostreambuf_iterator& operator=(_CharT __c) { if (!_M_failed && _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) _M_failed = true; return *this; } [[__nodiscard__]] ostreambuf_iterator& operator*() { return *this; } ostreambuf_iterator& operator++(int) { return *this; } ostreambuf_iterator& operator++() { return *this; } [[__nodiscard__]] bool failed() const noexcept { return _M_failed; } ostreambuf_iterator& _M_put(const _CharT* __ws, streamsize __len) { if (__builtin_expect(!_M_failed, true) && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false)) _M_failed = true; return *this; } }; #pragma GCC diagnostic pop template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT> >::__type copy(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last, ostreambuf_iterator<_CharT> __result) { if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) { bool __ineof; __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); if (!__ineof) __result._M_failed = true; } return __result; } template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT> >::__type __copy_move_a2(_CharT* __first, _CharT* __last, ostreambuf_iterator<_CharT> __result) { const streamsize __num = __last - __first; if (__num > 0) __result._M_put(__first, __num); return __result; } template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT> >::__type __copy_move_a2(const _CharT* __first, const _CharT* __last, ostreambuf_iterator<_CharT> __result) { const streamsize __num = __last - __first; if (__num > 0) __result._M_put(__first, __num); return __result; } template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT*>::__type __copy_move_a2(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last, _CharT* __result) { typedef istreambuf_iterator<_CharT> __is_iterator_type; typedef typename __is_iterator_type::traits_type traits_type; typedef typename __is_iterator_type::streambuf_type streambuf_type; typedef typename traits_type::int_type int_type; if (__first._M_sbuf && !__last._M_sbuf) { streambuf_type* __sb = __first._M_sbuf; int_type __c = __sb->sgetc(); while (!traits_type::eq_int_type(__c, traits_type::eof())) { const streamsize __n = __sb->egptr() - __sb->gptr(); if (__n > 1) { traits_type::copy(__result, __sb->gptr(), __n); __sb->__safe_gbump(__n); __result += __n; __c = __sb->underflow(); } else { *__result++ = traits_type::to_char_type(__c); __c = __sb->snextc(); } } } return __result; } template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT*>::__type __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result, bool __strict __attribute__((__unused__))) { if (__n == 0) return __result; ; _CharT* __beg = __result; __result += __it._M_sbuf->sgetn(__beg, __n); ; return __result; } template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, istreambuf_iterator<_CharT> >::__type find(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last, const _CharT& __val) { typedef istreambuf_iterator<_CharT> __is_iterator_type; typedef typename __is_iterator_type::traits_type traits_type; typedef typename __is_iterator_type::streambuf_type streambuf_type; typedef typename traits_type::int_type int_type; const int_type __eof = traits_type::eof(); if (__first._M_sbuf && !__last._M_sbuf) { const int_type __ival = traits_type::to_int_type(__val); streambuf_type* __sb = __first._M_sbuf; int_type __c = __sb->sgetc(); while (!traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __ival)) { streamsize __n = __sb->egptr() - __sb->gptr(); if (__n > 1) { const _CharT* __p = traits_type::find(__sb->gptr(), __n, __val); if (__p) __n = __p - __sb->gptr(); __sb->__safe_gbump(__n); __c = __sb->sgetc(); } else __c = __sb->snextc(); } __first._M_c = __eof; } return __first; } template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, void>::__type advance(istreambuf_iterator<_CharT>& __i, _Distance __n) { if (__n == 0) return; do { if (std::__is_constant_evaluated() && !bool(__n > 0)) std::__glibcxx_assert_fail(); } while (false); ; typedef istreambuf_iterator<_CharT> __is_iterator_type; typedef typename __is_iterator_type::traits_type traits_type; typedef typename __is_iterator_type::streambuf_type streambuf_type; typedef typename traits_type::int_type int_type; const int_type __eof = traits_type::eof(); streambuf_type* __sb = __i._M_sbuf; while (__n > 0) { streamsize __size = __sb->egptr() - __sb->gptr(); if (__size > __n) { __sb->__safe_gbump(__n); break; } __sb->__safe_gbump(__size); __n -= __size; if (traits_type::eq_int_type(__sb->underflow(), __eof)) { ; break; } } __i._M_c = __eof; } } # 51 "/usr/include/c++/15/bits/locale_facets.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 76 "/usr/include/c++/15/bits/locale_facets.h" 3 template void __convert_to_v(const char*, _Tp&, ios_base::iostate&, const __c_locale&) throw(); template<> void __convert_to_v(const char*, float&, ios_base::iostate&, const __c_locale&) throw(); template<> void __convert_to_v(const char*, double&, ios_base::iostate&, const __c_locale&) throw(); template<> void __convert_to_v(const char*, long double&, ios_base::iostate&, const __c_locale&) throw(); template struct __pad { static void _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds, streamsize __newlen, streamsize __oldlen); }; template _CharT* __add_grouping(_CharT* __s, _CharT __sep, const char* __gbeg, size_t __gsize, const _CharT* __first, const _CharT* __last); template inline ostreambuf_iterator<_CharT> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) { __s._M_put(__ws, __len); return __s; } template inline _OutIter __write(_OutIter __s, const _CharT* __ws, int __len) { for (int __j = 0; __j < __len; __j++, ++__s) *__s = __ws[__j]; return __s; } # 154 "/usr/include/c++/15/bits/locale_facets.h" 3 template class __ctype_abstract_base : public locale::facet, public ctype_base { public: typedef _CharT char_type; # 173 "/usr/include/c++/15/bits/locale_facets.h" 3 bool is(mask __m, char_type __c) const { return this->do_is(__m, __c); } # 190 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* is(const char_type *__lo, const char_type *__hi, mask *__vec) const { return this->do_is(__lo, __hi, __vec); } # 206 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* scan_is(mask __m, const char_type* __lo, const char_type* __hi) const { return this->do_scan_is(__m, __lo, __hi); } # 222 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* scan_not(mask __m, const char_type* __lo, const char_type* __hi) const { return this->do_scan_not(__m, __lo, __hi); } # 236 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type toupper(char_type __c) const { return this->do_toupper(__c); } # 251 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* toupper(char_type *__lo, const char_type* __hi) const { return this->do_toupper(__lo, __hi); } # 265 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type tolower(char_type __c) const { return this->do_tolower(__c); } # 280 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* tolower(char_type* __lo, const char_type* __hi) const { return this->do_tolower(__lo, __hi); } # 297 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type widen(char __c) const { return this->do_widen(__c); } # 316 "/usr/include/c++/15/bits/locale_facets.h" 3 const char* widen(const char* __lo, const char* __hi, char_type* __to) const { return this->do_widen(__lo, __hi, __to); } # 335 "/usr/include/c++/15/bits/locale_facets.h" 3 char narrow(char_type __c, char __dfault) const { return this->do_narrow(__c, __dfault); } # 357 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const { return this->do_narrow(__lo, __hi, __dfault, __to); } protected: explicit __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } virtual ~__ctype_abstract_base() { } # 382 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual bool do_is(mask __m, char_type __c) const = 0; # 401 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const = 0; # 420 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const = 0; # 439 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const = 0; # 457 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_toupper(char_type __c) const = 0; # 474 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const = 0; # 490 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_tolower(char_type __c) const = 0; # 507 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const = 0; # 526 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_widen(char __c) const = 0; # 547 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; # 568 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char do_narrow(char_type __c, char __dfault) const = 0; # 593 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const = 0; }; # 616 "/usr/include/c++/15/bits/locale_facets.h" 3 template class ctype : public __ctype_abstract_base<_CharT> { public: typedef _CharT char_type; typedef typename __ctype_abstract_base<_CharT>::mask mask; static locale::id id; explicit ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } protected: virtual ~ctype(); virtual bool do_is(mask __m, char_type __c) const; virtual const char_type* do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; virtual const char_type* do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; virtual const char_type* do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const; virtual char_type do_toupper(char_type __c) const; virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const; virtual char_type do_tolower(char_type __c) const; virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const; virtual char_type do_widen(char __c) const; virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __dest) const; virtual char do_narrow(char_type, char __dfault) const; virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const; }; template locale::id ctype<_CharT>::id; template class ctype >; # 690 "/usr/include/c++/15/bits/locale_facets.h" 3 template<> class ctype : public locale::facet, public ctype_base { public: typedef char char_type; protected: __c_locale _M_c_locale_ctype; bool _M_del; __to_type _M_toupper; __to_type _M_tolower; const mask* _M_table; mutable char _M_widen_ok; mutable char _M_widen[1 + static_cast(-1)]; mutable char _M_narrow[1 + static_cast(-1)]; mutable char _M_narrow_ok; public: static locale::id id; static const size_t table_size = 1 + static_cast(-1); # 727 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); # 740 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, size_t __refs = 0); # 753 "/usr/include/c++/15/bits/locale_facets.h" 3 inline bool is(mask __m, char __c) const; # 768 "/usr/include/c++/15/bits/locale_facets.h" 3 inline const char* is(const char* __lo, const char* __hi, mask* __vec) const; # 782 "/usr/include/c++/15/bits/locale_facets.h" 3 inline const char* scan_is(mask __m, const char* __lo, const char* __hi) const; # 796 "/usr/include/c++/15/bits/locale_facets.h" 3 inline const char* scan_not(mask __m, const char* __lo, const char* __hi) const; # 811 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type toupper(char_type __c) const { return this->do_toupper(__c); } # 828 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* toupper(char_type *__lo, const char_type* __hi) const { return this->do_toupper(__lo, __hi); } # 844 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type tolower(char_type __c) const { return this->do_tolower(__c); } # 861 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* tolower(char_type* __lo, const char_type* __hi) const { return this->do_tolower(__lo, __hi); } # 881 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type widen(char __c) const { if (_M_widen_ok) return _M_widen[static_cast(__c)]; this->_M_widen_init(); return this->do_widen(__c); } # 908 "/usr/include/c++/15/bits/locale_facets.h" 3 const char* widen(const char* __lo, const char* __hi, char_type* __to) const { if (_M_widen_ok == 1) { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } if (!_M_widen_ok) _M_widen_init(); return this->do_widen(__lo, __hi, __to); } # 940 "/usr/include/c++/15/bits/locale_facets.h" 3 char narrow(char_type __c, char __dfault) const { if (_M_narrow[static_cast(__c)]) return _M_narrow[static_cast(__c)]; const char __t = do_narrow(__c, __dfault); if (__t != __dfault) _M_narrow[static_cast(__c)] = __t; return __t; } # 973 "/usr/include/c++/15/bits/locale_facets.h" 3 const char_type* narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const { if (__builtin_expect(_M_narrow_ok == 1, true)) { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } if (!_M_narrow_ok) _M_narrow_init(); return this->do_narrow(__lo, __hi, __dfault, __to); } const mask* table() const throw() { return _M_table; } static const mask* classic_table() throw(); protected: virtual ~ctype(); # 1023 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_toupper(char_type __c) const; # 1040 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const; # 1056 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_tolower(char_type __c) const; # 1073 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const; # 1093 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_widen(char __c) const { return __c; } # 1116 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __to) const { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } # 1143 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const { return __c; } # 1169 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault __attribute__((__unused__)), char* __to) const { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } private: void _M_narrow_init() const; void _M_widen_init() const; }; # 1195 "/usr/include/c++/15/bits/locale_facets.h" 3 template<> class ctype : public __ctype_abstract_base { public: typedef wchar_t char_type; typedef wctype_t __wmask_type; protected: __c_locale _M_c_locale_ctype; bool _M_narrow_ok; char _M_narrow[128]; wint_t _M_widen[1 + static_cast(-1)]; mask _M_bit[16]; __wmask_type _M_wmask[16]; public: static locale::id id; # 1228 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit ctype(size_t __refs = 0); # 1239 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit ctype(__c_locale __cloc, size_t __refs = 0); protected: __wmask_type _M_convert_to_wmask(const mask __m) const throw(); virtual ~ctype(); # 1263 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual bool do_is(mask __m, char_type __c) const; # 1282 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; # 1300 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; # 1318 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const; # 1335 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_toupper(char_type __c) const; # 1352 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const; # 1368 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_tolower(char_type __c) const; # 1385 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const; # 1405 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_widen(char __c) const; # 1427 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __to) const; # 1450 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char do_narrow(char_type __c, char __dfault) const; # 1476 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const; void _M_initialize_ctype() throw(); }; template class ctype_byname : public ctype<_CharT> { public: typedef typename ctype<_CharT>::mask mask; explicit ctype_byname(const char* __s, size_t __refs = 0); explicit ctype_byname(const string& __s, size_t __refs = 0) : ctype_byname(__s.c_str(), __refs) { } protected: virtual ~ctype_byname() { } }; template<> class ctype_byname : public ctype { public: explicit ctype_byname(const char* __s, size_t __refs = 0); explicit ctype_byname(const string& __s, size_t __refs = 0); protected: virtual ~ctype_byname(); }; template<> class ctype_byname : public ctype { public: explicit ctype_byname(const char* __s, size_t __refs = 0); explicit ctype_byname(const string& __s, size_t __refs = 0); protected: virtual ~ctype_byname(); }; } # 1 "/usr/include/riscv64-linux-gnu/c++/15/bits/ctype_inline.h" 1 3 # 37 "/usr/include/riscv64-linux-gnu/c++/15/bits/ctype_inline.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { bool ctype:: is(mask __m, char __c) const { return _M_table[static_cast(__c)] & __m; } const char* ctype:: is(const char* __low, const char* __high, mask* __vec) const { while (__low < __high) *__vec++ = _M_table[static_cast(*__low++)]; return __high; } const char* ctype:: scan_is(mask __m, const char* __low, const char* __high) const { while (__low < __high && !(_M_table[static_cast(*__low)] & __m)) ++__low; return __low; } const char* ctype:: scan_not(mask __m, const char* __low, const char* __high) const { while (__low < __high && (_M_table[static_cast(*__low)] & __m) != 0) ++__low; return __low; } } # 1549 "/usr/include/c++/15/bits/locale_facets.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { class __num_base { public: enum { _S_ominus, _S_oplus, _S_ox, _S_oX, _S_odigits, _S_odigits_end = _S_odigits + 16, _S_oudigits = _S_odigits_end, _S_oudigits_end = _S_oudigits + 16, _S_oe = _S_odigits + 14, _S_oE = _S_oudigits + 14, _S_oend = _S_oudigits_end }; static const char* _S_atoms_out; static const char* _S_atoms_in; enum { _S_iminus, _S_iplus, _S_ix, _S_iX, _S_izero, _S_ie = _S_izero + 14, _S_iE = _S_izero + 20, _S_iend = 26 }; static void _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); }; template struct __numpunct_cache : public locale::facet { const char* _M_grouping; size_t _M_grouping_size; bool _M_use_grouping; const _CharT* _M_truename; size_t _M_truename_size; const _CharT* _M_falsename; size_t _M_falsename_size; _CharT _M_decimal_point; _CharT _M_thousands_sep; _CharT _M_atoms_out[__num_base::_S_oend]; _CharT _M_atoms_in[__num_base::_S_iend]; bool _M_allocated; __numpunct_cache(size_t __refs = 0) : facet(__refs), _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false), _M_truename(0), _M_truename_size(0), _M_falsename(0), _M_falsename_size(0), _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()), _M_allocated(false) { } ~__numpunct_cache(); void _M_cache(const locale& __loc); private: __numpunct_cache& operator=(const __numpunct_cache&); explicit __numpunct_cache(const __numpunct_cache&); }; template __numpunct_cache<_CharT>::~__numpunct_cache() { if (_M_allocated) { delete [] _M_grouping; delete [] _M_truename; delete [] _M_falsename; } } namespace __cxx11 { # 1679 "/usr/include/c++/15/bits/locale_facets.h" 3 template class numpunct : public locale::facet { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; typedef __numpunct_cache<_CharT> __cache_type; protected: __cache_type* _M_data; public: static locale::id id; explicit numpunct(size_t __refs = 0) : facet(__refs), _M_data(0) { _M_initialize_numpunct(); } # 1717 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit numpunct(__cache_type* __cache, size_t __refs = 0) : facet(__refs), _M_data(__cache) { _M_initialize_numpunct(); } # 1731 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit numpunct(__c_locale __cloc, size_t __refs = 0) : facet(__refs), _M_data(0) { _M_initialize_numpunct(__cloc); } # 1745 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type decimal_point() const { return this->do_decimal_point(); } # 1758 "/usr/include/c++/15/bits/locale_facets.h" 3 char_type thousands_sep() const { return this->do_thousands_sep(); } # 1789 "/usr/include/c++/15/bits/locale_facets.h" 3 string grouping() const { return this->do_grouping(); } # 1802 "/usr/include/c++/15/bits/locale_facets.h" 3 string_type truename() const { return this->do_truename(); } # 1815 "/usr/include/c++/15/bits/locale_facets.h" 3 string_type falsename() const { return this->do_falsename(); } protected: virtual ~numpunct(); # 1832 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_decimal_point() const { return _M_data->_M_decimal_point; } # 1844 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual char_type do_thousands_sep() const { return _M_data->_M_thousands_sep; } # 1857 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual string do_grouping() const { return _M_data->_M_grouping; } # 1870 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual string_type do_truename() const { return _M_data->_M_truename; } # 1883 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual string_type do_falsename() const { return _M_data->_M_falsename; } void _M_initialize_numpunct(__c_locale __cloc = 0); }; template locale::id numpunct<_CharT>::id; template<> numpunct::~numpunct(); template<> void numpunct::_M_initialize_numpunct(__c_locale __cloc); template<> numpunct::~numpunct(); template<> void numpunct::_M_initialize_numpunct(__c_locale __cloc); template class numpunct_byname : public numpunct<_CharT> { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; explicit numpunct_byname(const char* __s, size_t __refs = 0) : numpunct<_CharT>(__refs) { if (__builtin_strcmp(__s, "C") != 0 && __builtin_strcmp(__s, "POSIX") != 0) { __c_locale __tmp; this->_S_create_c_locale(__tmp, __s); this->_M_initialize_numpunct(__tmp); this->_S_destroy_c_locale(__tmp); } } explicit numpunct_byname(const string& __s, size_t __refs = 0) : numpunct_byname(__s.c_str(), __refs) { } protected: virtual ~numpunct_byname() { } }; } # 1961 "/usr/include/c++/15/bits/locale_facets.h" 3 template class num_get : public locale::facet { public: typedef _CharT char_type; typedef _InIter iter_type; static locale::id id; # 1982 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit num_get(size_t __refs = 0) : facet(__refs) { } # 2008 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool& __v) const { return this->do_get(__in, __end, __io, __err, __v); } # 2045 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned short& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned int& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, long long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } #pragma GCC diagnostic pop # 2108 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, float& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, double& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, long double& __v) const { return this->do_get(__in, __end, __io, __err, __v); } # 2151 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, void*& __v) const { return this->do_get(__in, __end, __io, __err, __v); } protected: virtual ~num_get() { } __attribute ((__abi_tag__ ("cxx11"))) iter_type _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, string&) const; template __attribute ((__abi_tag__ ("cxx11"))) iter_type _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, _ValueT&) const; template typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type _M_find(const _CharT2*, size_t __len, _CharT2 __c) const { int __ret = -1; if (__len <= 10) { if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) __ret = __c - _CharT2('0'); } else { if (__c >= _CharT2('0') && __c <= _CharT2('9')) __ret = __c - _CharT2('0'); else if (__c >= _CharT2('a') && __c <= _CharT2('f')) __ret = 10 + (__c - _CharT2('a')); else if (__c >= _CharT2('A') && __c <= _CharT2('F')) __ret = 10 + (__c - _CharT2('A')); } return __ret; } template typename __gnu_cxx::__enable_if::__value, int>::__type _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const { int __ret = -1; const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); if (__q) { __ret = __q - __zero; if (__ret > 15) __ret -= 6; } return __ret; } # 2224 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned short& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned int& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } #pragma GCC diagnostic pop virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, double&) const; # 2279 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long double&) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; # 2307 "/usr/include/c++/15/bits/locale_facets.h" 3 }; template locale::id num_get<_CharT, _InIter>::id; # 2325 "/usr/include/c++/15/bits/locale_facets.h" 3 template class num_put : public locale::facet { public: typedef _CharT char_type; typedef _OutIter iter_type; static locale::id id; # 2346 "/usr/include/c++/15/bits/locale_facets.h" 3 explicit num_put(size_t __refs = 0) : facet(__refs) { } # 2364 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const { return this->do_put(__s, __io, __fill, __v); } # 2406 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, long __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, unsigned long __v) const { return this->do_put(__s, __io, __fill, __v); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" iter_type put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, unsigned long long __v) const { return this->do_put(__s, __io, __fill, __v); } #pragma GCC diagnostic pop # 2472 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, double __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, long double __v) const { return this->do_put(__s, __io, __fill, __v); } # 2497 "/usr/include/c++/15/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, const void* __v) const { return this->do_put(__s, __io, __fill, __v); } protected: template iter_type _M_insert_float(iter_type, ios_base& __io, char_type __fill, char __mod, _ValueT __v) const; void _M_group_float(const char* __grouping, size_t __grouping_size, char_type __sep, const char_type* __p, char_type* __new, char_type* __cs, int& __len) const; template iter_type _M_insert_int(iter_type, ios_base& __io, char_type __fill, _ValueT __v) const; void _M_group_int(const char* __grouping, size_t __grouping_size, char_type __sep, ios_base& __io, char_type* __new, char_type* __cs, int& __len) const; void _M_pad(char_type __fill, streamsize __w, ios_base& __io, char_type* __new, const char_type* __cs, int& __len) const; virtual ~num_put() { } # 2545 "/usr/include/c++/15/bits/locale_facets.h" 3 virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const { return _M_insert_int(__s, __io, __fill, __v); } virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, unsigned long __v) const { return _M_insert_int(__s, __io, __fill, __v); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const { return _M_insert_int(__s, __io, __fill, __v); } virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, unsigned long long __v) const { return _M_insert_int(__s, __io, __fill, __v); } #pragma GCC diagnostic pop virtual iter_type do_put(iter_type, ios_base&, char_type, double) const; virtual iter_type do_put(iter_type, ios_base&, char_type, long double) const; virtual iter_type do_put(iter_type, ios_base&, char_type, const void*) const; # 2600 "/usr/include/c++/15/bits/locale_facets.h" 3 }; template locale::id num_put<_CharT, _OutIter>::id; template inline bool isspace(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::space, __c); } template inline bool isprint(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::print, __c); } template inline bool iscntrl(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::cntrl, __c); } template inline bool isupper(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::upper, __c); } template inline bool islower(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::lower, __c); } template inline bool isalpha(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::alpha, __c); } template inline bool isdigit(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::digit, __c); } template inline bool ispunct(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::punct, __c); } template inline bool isxdigit(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::xdigit, __c); } template inline bool isalnum(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::alnum, __c); } template inline bool isgraph(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::graph, __c); } template inline bool isblank(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::blank, __c); } template inline _CharT toupper(_CharT __c, const locale& __loc) { return use_facet >(__loc).toupper(__c); } template inline _CharT tolower(_CharT __c, const locale& __loc) { return use_facet >(__loc).tolower(__c); } } # 1 "/usr/include/c++/15/bits/locale_facets.tcc" 1 3 # 36 "/usr/include/c++/15/bits/locale_facets.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template struct __use_cache { const _Facet* operator() (const locale& __loc) const; }; template struct __use_cache<__numpunct_cache<_CharT> > { const __numpunct_cache<_CharT>* operator() (const locale& __loc) const { const size_t __i = numpunct<_CharT>::id._M_id(); const locale::facet** __caches = __loc._M_impl->_M_caches; if (!__caches[__i]) { __numpunct_cache<_CharT>* __tmp = 0; try { __tmp = new __numpunct_cache<_CharT>; __tmp->_M_cache(__loc); } catch(...) { delete __tmp; throw; } __loc._M_impl->_M_install_cache(__tmp, __i); } return static_cast*>(__caches[__i]); } }; template void __numpunct_cache<_CharT>::_M_cache(const locale& __loc) { const numpunct<_CharT>& __np = use_facet >(__loc); char* __grouping = 0; _CharT* __truename = 0; _CharT* __falsename = 0; try { const string& __g = __np.grouping(); _M_grouping_size = __g.size(); __grouping = new char[_M_grouping_size]; __g.copy(__grouping, _M_grouping_size); _M_use_grouping = (_M_grouping_size && static_cast(__grouping[0]) > 0 && (__grouping[0] != __gnu_cxx::__numeric_traits::__max)); const basic_string<_CharT>& __tn = __np.truename(); _M_truename_size = __tn.size(); __truename = new _CharT[_M_truename_size]; __tn.copy(__truename, _M_truename_size); const basic_string<_CharT>& __fn = __np.falsename(); _M_falsename_size = __fn.size(); __falsename = new _CharT[_M_falsename_size]; __fn.copy(__falsename, _M_falsename_size); _M_decimal_point = __np.decimal_point(); _M_thousands_sep = __np.thousands_sep(); const ctype<_CharT>& __ct = use_facet >(__loc); __ct.widen(__num_base::_S_atoms_out, __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out); __ct.widen(__num_base::_S_atoms_in, __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in); _M_grouping = __grouping; _M_truename = __truename; _M_falsename = __falsename; _M_allocated = true; } catch(...) { delete [] __grouping; delete [] __truename; delete [] __falsename; throw; } } # 143 "/usr/include/c++/15/bits/locale_facets.tcc" 3 __attribute__ ((__pure__)) bool __verify_grouping(const char* __grouping, size_t __grouping_size, const string& __grouping_tmp) throw (); template __attribute ((__abi_tag__ ("cxx11"))) _InIter num_get<_CharT, _InIter>:: _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, ios_base::iostate& __err, string& __xtrc) const { typedef char_traits<_CharT> __traits_type; typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc->_M_atoms_in; char_type __c = char_type(); bool __testeof = __beg == __end; if (!__testeof) { __c = *__beg; const bool __plus = __c == __lit[__num_base::_S_iplus]; if ((__plus || __c == __lit[__num_base::_S_iminus]) && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) && !(__c == __lc->_M_decimal_point)) { __xtrc += __plus ? '+' : '-'; if (++__beg != __end) __c = *__beg; else __testeof = true; } } bool __found_mantissa = false; int __sep_pos = 0; while (!__testeof) { if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) || __c == __lc->_M_decimal_point) break; else if (__c == __lit[__num_base::_S_izero]) { if (!__found_mantissa) { __xtrc += '0'; __found_mantissa = true; } ++__sep_pos; if (++__beg != __end) __c = *__beg; else __testeof = true; } else break; } bool __found_dec = false; bool __found_sci = false; string __found_grouping; if (__lc->_M_use_grouping) __found_grouping.reserve(32); const char_type* __lit_zero = __lit + __num_base::_S_izero; if (!__lc->_M_allocated) while (!__testeof) { const int __digit = _M_find(__lit_zero, 10, __c); if (__digit != -1) { __xtrc += '0' + __digit; __found_mantissa = true; } else if (__c == __lc->_M_decimal_point && !__found_dec && !__found_sci) { __xtrc += '.'; __found_dec = true; } else if ((__c == __lit[__num_base::_S_ie] || __c == __lit[__num_base::_S_iE]) && !__found_sci && __found_mantissa) { __xtrc += 'e'; __found_sci = true; if (++__beg != __end) { __c = *__beg; const bool __plus = __c == __lit[__num_base::_S_iplus]; if (__plus || __c == __lit[__num_base::_S_iminus]) __xtrc += __plus ? '+' : '-'; else continue; } else { __testeof = true; break; } } else break; if (++__beg != __end) __c = *__beg; else __testeof = true; } else while (!__testeof) { if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) { if (!__found_dec && !__found_sci) { if (__sep_pos) { __found_grouping += static_cast(__sep_pos); __sep_pos = 0; } else { __xtrc.clear(); break; } } else break; } else if (__c == __lc->_M_decimal_point) { if (!__found_dec && !__found_sci) { if (__found_grouping.size()) __found_grouping += static_cast(__sep_pos); __xtrc += '.'; __found_dec = true; } else break; } else { const char_type* __q = __traits_type::find(__lit_zero, 10, __c); if (__q) { __xtrc += '0' + (__q - __lit_zero); __found_mantissa = true; ++__sep_pos; } else if ((__c == __lit[__num_base::_S_ie] || __c == __lit[__num_base::_S_iE]) && !__found_sci && __found_mantissa) { if (__found_grouping.size() && !__found_dec) __found_grouping += static_cast(__sep_pos); __xtrc += 'e'; __found_sci = true; if (++__beg != __end) { __c = *__beg; const bool __plus = __c == __lit[__num_base::_S_iplus]; if ((__plus || __c == __lit[__num_base::_S_iminus]) && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) && !(__c == __lc->_M_decimal_point)) __xtrc += __plus ? '+' : '-'; else continue; } else { __testeof = true; break; } } else break; } if (++__beg != __end) __c = *__beg; else __testeof = true; } if (__found_grouping.size()) { if (!__found_dec && !__found_sci) __found_grouping += static_cast(__sep_pos); if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size, __found_grouping)) __err = ios_base::failbit; } return __beg; } template template __attribute ((__abi_tag__ ("cxx11"))) _InIter num_get<_CharT, _InIter>:: _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, ios_base::iostate& __err, _ValueT& __v) const { typedef char_traits<_CharT> __traits_type; using __gnu_cxx::__add_unsigned; typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc->_M_atoms_in; char_type __c = char_type(); const ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield; const bool __oct = __basefield == ios_base::oct; int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10); bool __testeof = __beg == __end; bool __negative = false; if (!__testeof) { __c = *__beg; __negative = __c == __lit[__num_base::_S_iminus]; if ((__negative || __c == __lit[__num_base::_S_iplus]) && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) && !(__c == __lc->_M_decimal_point)) { if (++__beg != __end) __c = *__beg; else __testeof = true; } } bool __found_zero = false; int __sep_pos = 0; while (!__testeof) { if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) || __c == __lc->_M_decimal_point) break; else if (__c == __lit[__num_base::_S_izero] && (!__found_zero || __base == 10)) { __found_zero = true; ++__sep_pos; if (__basefield == 0) __base = 8; if (__base == 8) __sep_pos = 0; } else if (__found_zero && (__c == __lit[__num_base::_S_ix] || __c == __lit[__num_base::_S_iX])) { if (__basefield == 0) __base = 16; if (__base == 16) { __found_zero = false; __sep_pos = 0; } else break; } else break; if (++__beg != __end) { __c = *__beg; if (!__found_zero) break; } else __testeof = true; } const size_t __len = (__base == 16 ? __num_base::_S_iend - __num_base::_S_izero : __base); typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits; string __found_grouping; if (__lc->_M_use_grouping) __found_grouping.reserve(32); bool __testfail = false; bool __testoverflow = false; const __unsigned_type __max = (__negative && __num_traits::__is_signed) ? -static_cast<__unsigned_type>(__num_traits::__min) : __num_traits::__max; const __unsigned_type __smax = __max / __base; __unsigned_type __result = 0; int __digit = 0; const char_type* __lit_zero = __lit + __num_base::_S_izero; if (!__lc->_M_allocated) while (!__testeof) { __digit = _M_find(__lit_zero, __len, __c); if (__digit == -1) break; if (__result > __smax) __testoverflow = true; else { __result *= __base; __testoverflow |= __result > __max - __digit; __result += __digit; ++__sep_pos; } if (++__beg != __end) __c = *__beg; else __testeof = true; } else while (!__testeof) { if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) { if (__sep_pos) { __found_grouping += static_cast(__sep_pos); __sep_pos = 0; } else { __testfail = true; break; } } else if (__c == __lc->_M_decimal_point) break; else { const char_type* __q = __traits_type::find(__lit_zero, __len, __c); if (!__q) break; __digit = __q - __lit_zero; if (__digit > 15) __digit -= 6; if (__result > __smax) __testoverflow = true; else { __result *= __base; __testoverflow |= __result > __max - __digit; __result += __digit; ++__sep_pos; } } if (++__beg != __end) __c = *__beg; else __testeof = true; } if (__found_grouping.size()) { __found_grouping += static_cast(__sep_pos); if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size, __found_grouping)) __err = ios_base::failbit; } if ((!__sep_pos && !__found_zero && !__found_grouping.size()) || __testfail) { __v = 0; __err = ios_base::failbit; } else if (__testoverflow) { if (__negative && __num_traits::__is_signed) __v = __num_traits::__min; else __v = __num_traits::__max; __err = ios_base::failbit; } else __v = __negative ? -__result : __result; if (__testeof) __err |= ios_base::eofbit; return __beg; } template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool& __v) const { if (!(__io.flags() & ios_base::boolalpha)) { long __l = -1; __beg = _M_extract_int(__beg, __end, __io, __err, __l); if (__l == 0 || __l == 1) __v = bool(__l); else { __v = true; __err = ios_base::failbit; if (__beg == __end) __err |= ios_base::eofbit; } } else { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); bool __testf = true; bool __testt = true; bool __donef = __lc->_M_falsename_size == 0; bool __donet = __lc->_M_truename_size == 0; bool __testeof = false; size_t __n = 0; while (!__donef || !__donet) { if (__beg == __end) { __testeof = true; break; } const char_type __c = *__beg; if (!__donef) __testf = __c == __lc->_M_falsename[__n]; if (!__testf && __donet) break; if (!__donet) __testt = __c == __lc->_M_truename[__n]; if (!__testt && __donef) break; if (!__testt && !__testf) break; ++__n; ++__beg; __donef = !__testf || __n >= __lc->_M_falsename_size; __donet = !__testt || __n >= __lc->_M_truename_size; } if (__testf && __n == __lc->_M_falsename_size && __n) { __v = false; if (__testt && __n == __lc->_M_truename_size) __err = ios_base::failbit; else __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else if (__testt && __n == __lc->_M_truename_size && __n) { __v = true; __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else { __v = false; __err = ios_base::failbit; if (__testeof) __err |= ios_base::eofbit; } } return __beg; } template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, float& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, double& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } # 739 "/usr/include/c++/15/bits/locale_facets.tcc" 3 template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long double& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, void*& __v) const { typedef ios_base::fmtflags fmtflags; const fmtflags __fmt = __io.flags(); __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" typedef __gnu_cxx::__conditional_type<(sizeof(void*) <= sizeof(unsigned long)), unsigned long, unsigned long long>::__type _UIntPtrType; #pragma GCC diagnostic pop _UIntPtrType __ul; __beg = _M_extract_int(__beg, __end, __io, __err, __ul); __io.flags(__fmt); __v = reinterpret_cast(__ul); return __beg; } # 802 "/usr/include/c++/15/bits/locale_facets.tcc" 3 template void num_put<_CharT, _OutIter>:: _M_pad(_CharT __fill, streamsize __w, ios_base& __io, _CharT* __new, const _CharT* __cs, int& __len) const { __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs, __w, __len); __len = static_cast(__w); } template int __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, ios_base::fmtflags __flags, bool __dec) { _CharT* __buf = __bufend; if (__builtin_expect(__dec, true)) { do { *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; __v /= 10; } while (__v != 0); } else if ((__flags & ios_base::basefield) == ios_base::oct) { do { *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; __v >>= 3; } while (__v != 0); } else { const bool __uppercase = __flags & ios_base::uppercase; const int __case_offset = __uppercase ? __num_base::_S_oudigits : __num_base::_S_odigits; do { *--__buf = __lit[(__v & 0xf) + __case_offset]; __v >>= 4; } while (__v != 0); } return __bufend - __buf; } template void num_put<_CharT, _OutIter>:: _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, ios_base&, _CharT* __new, _CharT* __cs, int& __len) const { _CharT* __p = std::__add_grouping(__new, __sep, __grouping, __grouping_size, __cs, __cs + __len); __len = __p - __new; } template template _OutIter num_put<_CharT, _OutIter>:: _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, _ValueT __v) const { using __gnu_cxx::__add_unsigned; typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc->_M_atoms_out; const ios_base::fmtflags __flags = __io.flags(); const int __ilen = 5 * sizeof(_ValueT); _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __ilen)); const ios_base::fmtflags __basefield = __flags & ios_base::basefield; const bool __dec = (__basefield != ios_base::oct && __basefield != ios_base::hex); const __unsigned_type __u = ((__v > 0 || !__dec) ? __unsigned_type(__v) : -__unsigned_type(__v)); int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); __cs += __ilen - __len; if (__lc->_M_use_grouping) { _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__len + 1) * 2)); _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); __cs = __cs2 + 2; } if (__builtin_expect(__dec, true)) { if (__v >= 0) { if (bool(__flags & ios_base::showpos) && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) *--__cs = __lit[__num_base::_S_oplus], ++__len; } else *--__cs = __lit[__num_base::_S_ominus], ++__len; } else if (bool(__flags & ios_base::showbase) && __v) { if (__basefield == ios_base::oct) *--__cs = __lit[__num_base::_S_odigits], ++__len; else { const bool __uppercase = __flags & ios_base::uppercase; *--__cs = __lit[__num_base::_S_ox + __uppercase]; *--__cs = __lit[__num_base::_S_odigits]; __len += 2; } } const streamsize __w = __io.width(); if (__w > static_cast(__len)) { _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); _M_pad(__fill, __w, __io, __cs3, __cs, __len); __cs = __cs3; } __io.width(0); return std::__write(__s, __cs, __len); } template void num_put<_CharT, _OutIter>:: _M_group_float(const char* __grouping, size_t __grouping_size, _CharT __sep, const _CharT* __p, _CharT* __new, _CharT* __cs, int& __len) const { const int __declen = __p ? __p - __cs : __len; _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, __grouping_size, __cs, __cs + __declen); int __newlen = __p2 - __new; if (__p) { char_traits<_CharT>::copy(__p2, __p, __len - __declen); __newlen += __len - __declen; } __len = __newlen; } # 996 "/usr/include/c++/15/bits/locale_facets.tcc" 3 template template _OutIter num_put<_CharT, _OutIter>:: _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, _ValueT __v) const { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision(); const int __max_digits = __gnu_cxx::__numeric_traits<_ValueT>::__digits10; int __len; char __fbuf[16]; __num_base::_S_format_float(__io, __fbuf, __mod); const bool __use_prec = (__io.flags() & ios_base::floatfield) != ios_base::floatfield; int __cs_size = __max_digits * 3; char* __cs = static_cast(__builtin_alloca(__cs_size)); if (__use_prec) __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __prec, __v); else __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __v); if (__len >= __cs_size) { __cs_size = __len + 1; __cs = static_cast(__builtin_alloca(__cs_size)); if (__use_prec) __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __prec, __v); else __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __v); } # 1069 "/usr/include/c++/15/bits/locale_facets.tcc" 3 const ctype<_CharT>& __ctype = use_facet >(__loc); _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len)); __ctype.widen(__cs, __cs + __len, __ws); _CharT* __wp = 0; const char* __p = char_traits::find(__cs, __len, '.'); if (__p) { __wp = __ws + (__p - __cs); *__wp = __lc->_M_decimal_point; } if (__lc->_M_use_grouping && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' && __cs[1] >= '0' && __cs[2] >= '0'))) { _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len * 2)); streamsize __off = 0; if (__cs[0] == '-' || __cs[0] == '+') { __off = 1; __ws2[0] = __ws[0]; __len -= 1; } _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, __lc->_M_thousands_sep, __wp, __ws2 + __off, __ws + __off, __len); __len += __off; __ws = __ws2; } const streamsize __w = __io.width(); if (__w > static_cast(__len)) { _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); _M_pad(__fill, __w, __io, __ws3, __ws, __len); __ws = __ws3; } __io.width(0); return std::__write(__s, __ws, __len); } template _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const { const ios_base::fmtflags __flags = __io.flags(); if ((__flags & ios_base::boolalpha) == 0) { const long __l = __v; __s = _M_insert_int(__s, __io, __fill, __l); } else { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __name = __v ? __lc->_M_truename : __lc->_M_falsename; int __len = __v ? __lc->_M_truename_size : __lc->_M_falsename_size; const streamsize __w = __io.width(); if (__w > static_cast(__len)) { const streamsize __plen = __w - __len; _CharT* __ps = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __plen)); char_traits<_CharT>::assign(__ps, __plen, __fill); __io.width(0); if ((__flags & ios_base::adjustfield) == ios_base::left) { __s = std::__write(__s, __name, __len); __s = std::__write(__s, __ps, __plen); } else { __s = std::__write(__s, __ps, __plen); __s = std::__write(__s, __name, __len); } return __s; } __io.width(0); __s = std::__write(__s, __name, __len); } return __s; } template _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const { return _M_insert_float(__s, __io, __fill, char(), __v); } # 1194 "/usr/include/c++/15/bits/locale_facets.tcc" 3 template _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, long double __v) const { return _M_insert_float(__s, __io, __fill, 'L', __v); } template _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, const void* __v) const { const ios_base::fmtflags __flags = __io.flags(); const ios_base::fmtflags __fmt = ~(ios_base::basefield | ios_base::uppercase); __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" typedef __gnu_cxx::__conditional_type<(sizeof(const void*) <= sizeof(unsigned long)), unsigned long, unsigned long long>::__type _UIntPtrType; #pragma GCC diagnostic pop __s = _M_insert_int(__s, __io, __fill, reinterpret_cast<_UIntPtrType>(__v)); __io.flags(__flags); return __s; } # 1234 "/usr/include/c++/15/bits/locale_facets.tcc" 3 # 1243 "/usr/include/c++/15/bits/locale_facets.tcc" 3 template void __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds, streamsize __newlen, streamsize __oldlen) { const size_t __plen = static_cast(__newlen - __oldlen); const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield; if (__adjust == ios_base::left) { _Traits::copy(__news, __olds, __oldlen); _Traits::assign(__news + __oldlen, __plen, __fill); return; } size_t __mod = 0; if (__adjust == ios_base::internal) { const locale& __loc = __io._M_getloc(); const ctype<_CharT>& __ctype = use_facet >(__loc); if (__ctype.widen('-') == __olds[0] || __ctype.widen('+') == __olds[0]) { __news[0] = __olds[0]; __mod = 1; ++__news; } else if (__ctype.widen('0') == __olds[0] && __oldlen > 1 && (__ctype.widen('x') == __olds[1] || __ctype.widen('X') == __olds[1])) { __news[0] = __olds[0]; __news[1] = __olds[1]; __mod = 2; __news += 2; } } _Traits::assign(__news, __plen, __fill); _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); } template _CharT* __add_grouping(_CharT* __s, _CharT __sep, const char* __gbeg, size_t __gsize, const _CharT* __first, const _CharT* __last) { size_t __idx = 0; size_t __ctr = 0; while (__last - __first > __gbeg[__idx] && static_cast(__gbeg[__idx]) > 0 && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__max) { __last -= __gbeg[__idx]; __idx < __gsize - 1 ? ++__idx : ++__ctr; } while (__first != __last) *__s++ = *__first++; while (__ctr--) { *__s++ = __sep; for (char __i = __gbeg[__idx]; __i > 0; --__i) *__s++ = *__first++; } while (__idx--) { *__s++ = __sep; for (char __i = __gbeg[__idx]; __i > 0; --__i) *__s++ = *__first++; } return __s; } extern template class __cxx11:: numpunct; extern template class __cxx11:: numpunct_byname; extern template class num_get; extern template class num_put; extern template class ctype_byname; extern template const ctype* __try_use_facet >(const locale&) noexcept; extern template const numpunct* __try_use_facet >(const locale&) noexcept; extern template const num_put* __try_use_facet >(const locale&) noexcept; extern template const num_get* __try_use_facet >(const locale&) noexcept; extern template const ctype& use_facet >(const locale&); extern template const numpunct& use_facet >(const locale&); extern template const num_put& use_facet >(const locale&); extern template const num_get& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class __cxx11:: numpunct; extern template class __cxx11:: numpunct_byname; extern template class num_get; extern template class num_put; extern template class ctype_byname; extern template const ctype* __try_use_facet >(const locale&) noexcept; extern template const numpunct* __try_use_facet >(const locale&) noexcept; extern template const num_put* __try_use_facet >(const locale&) noexcept; extern template const num_get* __try_use_facet >(const locale&) noexcept; extern template const ctype& use_facet >(const locale&); extern template const numpunct& use_facet >(const locale&); extern template const num_put& use_facet >(const locale&); extern template const num_get& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); } #pragma GCC diagnostic pop # 2702 "/usr/include/c++/15/bits/locale_facets.h" 2 3 # 40 "/usr/include/c++/15/bits/basic_ios.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline const _Facet& __check_facet(const _Facet* __f) { if (!__f) __throw_bad_cast(); return *__f; } # 68 "/usr/include/c++/15/bits/basic_ios.h" 3 template class basic_ios : public ios_base { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef ctype<_CharT> __ctype_type; typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > __num_put_type; typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > __num_get_type; protected: basic_ostream<_CharT, _Traits>* _M_tie; mutable char_type _M_fill; mutable bool _M_fill_init; basic_streambuf<_CharT, _Traits>* _M_streambuf; const __ctype_type* _M_ctype; const __num_put_type* _M_num_put; const __num_get_type* _M_num_get; public: # 123 "/usr/include/c++/15/bits/basic_ios.h" 3 [[__nodiscard__]] explicit operator bool() const { return !this->fail(); } [[__nodiscard__]] bool operator!() const { return this->fail(); } # 144 "/usr/include/c++/15/bits/basic_ios.h" 3 [[__nodiscard__]] iostate rdstate() const { return _M_streambuf_state; } # 156 "/usr/include/c++/15/bits/basic_ios.h" 3 void clear(iostate __state = goodbit); void setstate(iostate __state) { this->clear(this->rdstate() | __state); } void _M_setstate(iostate __state) { _M_streambuf_state |= __state; if (this->exceptions() & __state) { throw; } } [[__nodiscard__]] bool good() const { return this->rdstate() == 0; } [[__nodiscard__]] bool eof() const { return (this->rdstate() & eofbit) != 0; } # 211 "/usr/include/c++/15/bits/basic_ios.h" 3 [[__nodiscard__]] bool fail() const { return (this->rdstate() & (badbit | failbit)) != 0; } [[__nodiscard__]] bool bad() const { return (this->rdstate() & badbit) != 0; } # 234 "/usr/include/c++/15/bits/basic_ios.h" 3 [[__nodiscard__]] iostate exceptions() const { return _M_exception; } # 270 "/usr/include/c++/15/bits/basic_ios.h" 3 void exceptions(iostate __except) { _M_exception = __except; this->clear(_M_streambuf_state); } explicit basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) { this->init(__sb); } virtual ~basic_ios() { } # 308 "/usr/include/c++/15/bits/basic_ios.h" 3 [[__nodiscard__]] basic_ostream<_CharT, _Traits>* tie() const { return _M_tie; } # 321 "/usr/include/c++/15/bits/basic_ios.h" 3 basic_ostream<_CharT, _Traits>* tie(basic_ostream<_CharT, _Traits>* __tiestr) { basic_ostream<_CharT, _Traits>* __old = _M_tie; _M_tie = __tiestr; return __old; } [[__nodiscard__]] basic_streambuf<_CharT, _Traits>* rdbuf() const { return _M_streambuf; } # 362 "/usr/include/c++/15/bits/basic_ios.h" 3 basic_streambuf<_CharT, _Traits>* rdbuf(basic_streambuf<_CharT, _Traits>* __sb); # 376 "/usr/include/c++/15/bits/basic_ios.h" 3 basic_ios& copyfmt(const basic_ios& __rhs); [[__nodiscard__]] char_type fill() const { if (__builtin_expect(!_M_fill_init, false)) return this->widen(' '); return _M_fill; } # 403 "/usr/include/c++/15/bits/basic_ios.h" 3 char_type fill(char_type __ch) { char_type __old = _M_fill; _M_fill = __ch; _M_fill_init = true; return __old; } # 424 "/usr/include/c++/15/bits/basic_ios.h" 3 locale imbue(const locale& __loc); # 444 "/usr/include/c++/15/bits/basic_ios.h" 3 char narrow(char_type __c, char __dfault) const { return __check_facet(_M_ctype).narrow(__c, __dfault); } # 463 "/usr/include/c++/15/bits/basic_ios.h" 3 char_type widen(char __c) const { return __check_facet(_M_ctype).widen(__c); } protected: basic_ios() : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) { } void init(basic_streambuf<_CharT, _Traits>* __sb); basic_ios(const basic_ios&) = delete; basic_ios& operator=(const basic_ios&) = delete; void move(basic_ios& __rhs) { ios_base::_M_move(__rhs); _M_cache_locale(_M_ios_locale); this->tie(__rhs.tie(nullptr)); _M_fill = __rhs._M_fill; _M_fill_init = __rhs._M_fill_init; _M_streambuf = nullptr; } void move(basic_ios&& __rhs) { this->move(__rhs); } void swap(basic_ios& __rhs) noexcept { ios_base::_M_swap(__rhs); _M_cache_locale(_M_ios_locale); __rhs._M_cache_locale(__rhs._M_ios_locale); std::swap(_M_tie, __rhs._M_tie); std::swap(_M_fill, __rhs._M_fill); std::swap(_M_fill_init, __rhs._M_fill_init); } void set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb) { _M_streambuf = __sb; } void _M_cache_locale(const locale& __loc); }; } # 1 "/usr/include/c++/15/bits/basic_ios.tcc" 1 3 # 37 "/usr/include/c++/15/bits/basic_ios.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template void basic_ios<_CharT, _Traits>::clear(iostate __state) { if (this->rdbuf()) _M_streambuf_state = __state; else _M_streambuf_state = __state | badbit; if (this->exceptions() & this->rdstate()) __throw_ios_failure(("basic_ios::clear")); } template basic_streambuf<_CharT, _Traits>* basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) { basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; _M_streambuf = __sb; this->clear(); return __old; } template basic_ios<_CharT, _Traits>& basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) { if (this != std::__addressof(__rhs)) { _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? _M_local_word : new _Words[__rhs._M_word_size]; _Callback_list* __cb = __rhs._M_callbacks; if (__cb) __cb->_M_add_reference(); _M_call_callbacks(erase_event); if (_M_word != _M_local_word) { delete [] _M_word; _M_word = 0; } _M_dispose_callbacks(); _M_callbacks = __cb; for (int __i = 0; __i < __rhs._M_word_size; ++__i) __words[__i] = __rhs._M_word[__i]; _M_word = __words; _M_word_size = __rhs._M_word_size; this->flags(__rhs.flags()); this->width(__rhs.width()); this->precision(__rhs.precision()); this->tie(__rhs.tie()); this->fill(__rhs.fill()); _M_ios_locale = __rhs.getloc(); _M_cache_locale(_M_ios_locale); _M_call_callbacks(copyfmt_event); this->exceptions(__rhs.exceptions()); } return *this; } template locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc) { locale __old(this->getloc()); ios_base::imbue(__loc); _M_cache_locale(__loc); if (this->rdbuf() != 0) this->rdbuf()->pubimbue(__loc); return __old; } template void basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) { ios_base::_M_init(); _M_cache_locale(_M_ios_locale); # 153 "/usr/include/c++/15/bits/basic_ios.tcc" 3 if (_M_ctype) { _M_fill = _M_ctype->widen(' '); _M_fill_init = true; } else _M_fill_init = false; _M_tie = 0; _M_exception = goodbit; _M_streambuf = __sb; _M_streambuf_state = __sb ? goodbit : badbit; } template void basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) { _M_ctype = std::__try_use_facet<__ctype_type>(__loc); _M_num_put = std::__try_use_facet<__num_put_type>(__loc); _M_num_get = std::__try_use_facet<__num_get_type>(__loc); } extern template class basic_ios; extern template class basic_ios; } #pragma GCC diagnostic pop # 532 "/usr/include/c++/15/bits/basic_ios.h" 2 3 # 49 "/usr/include/c++/15/ios" 2 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 52 "/usr/include/c++/15/ios" 2 3 # 44 "/usr/include/c++/15/bits/ostream.h" 2 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 48 "/usr/include/c++/15/bits/ostream.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 65 "/usr/include/c++/15/bits/ostream.h" 3 template class basic_ostream : virtual public basic_ios<_CharT, _Traits> { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_ios<_CharT, _Traits> __ios_type; typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > __num_put_type; typedef ctype<_CharT> __ctype_type; # 91 "/usr/include/c++/15/bits/ostream.h" 3 explicit basic_ostream(__streambuf_type* __sb) { this->init(__sb); } virtual ~basic_ostream() { } class sentry; friend class sentry; # 115 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& operator<<(__ostream_type& (*__pf)(__ostream_type&)) { return __pf(*this); } __ostream_type& operator<<(__ios_type& (*__pf)(__ios_type&)) { __pf(*this); return *this; } __ostream_type& operator<<(ios_base& (*__pf) (ios_base&)) { __pf(*this); return *this; } # 173 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& operator<<(long __n) { return _M_insert(__n); } __ostream_type& operator<<(unsigned long __n) { return _M_insert(__n); } __ostream_type& operator<<(bool __n) { return _M_insert(__n); } __ostream_type& operator<<(short __n); __ostream_type& operator<<(unsigned short __n) { return _M_insert(static_cast(__n)); } __ostream_type& operator<<(int __n); __ostream_type& operator<<(unsigned int __n) { return _M_insert(static_cast(__n)); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" __ostream_type& operator<<(long long __n) { return _M_insert(__n); } __ostream_type& operator<<(unsigned long long __n) { return _M_insert(__n); } #pragma GCC diagnostic pop # 230 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& operator<<(double __f) { return _M_insert(__f); } __ostream_type& operator<<(float __f) { return _M_insert(_S_cast_flt(__f)); } __ostream_type& operator<<(long double __f) { return _M_insert(__f); } # 300 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& operator<<(const void* __p) { return _M_insert(__p); } __ostream_type& operator<<(nullptr_t) { return *this << "nullptr"; } # 338 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& operator<<(__streambuf_type* __sb); # 371 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& put(char_type __c); # 390 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& write(const char_type* __s, streamsize __n); # 403 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& flush(); # 413 "/usr/include/c++/15/bits/ostream.h" 3 pos_type tellp(); # 424 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& seekp(pos_type); # 436 "/usr/include/c++/15/bits/ostream.h" 3 __ostream_type& seekp(off_type, ios_base::seekdir); protected: basic_ostream() { this->init(0); } basic_ostream(basic_iostream<_CharT, _Traits>&) { } basic_ostream(const basic_ostream&) = delete; basic_ostream(basic_ostream&& __rhs) : __ios_type() { __ios_type::move(__rhs); } basic_ostream& operator=(const basic_ostream&) = delete; basic_ostream& operator=(basic_ostream&& __rhs) { swap(__rhs); return *this; } void swap(basic_ostream& __rhs) { __ios_type::swap(__rhs); } template __ostream_type& _M_insert(_ValueT __v); private: void _M_write(const char_type* __s, streamsize __n) { std::__ostream_insert(*this, __s, __n); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template static _To _S_cast_flt(_From __f) { _To __d = static_cast<_To>(__f); _To __sign; if constexpr (sizeof(__f) == sizeof(short)) __sign = static_cast<_To>(__builtin_bit_cast(short, __f)); else if constexpr (sizeof(__f) == sizeof(int)) __sign = static_cast<_To>(__builtin_bit_cast(int, __f)); else if constexpr (sizeof(__f) == sizeof(long long)) __sign = static_cast<_To>(__builtin_bit_cast(long long, __f)); else __sign = __builtin_signbit(__f) ? _To(-1.0) : _To(+1.0); if constexpr (__is_same(_To, double)) __d = __builtin_copysign(__d, __sign); else if constexpr (__is_same(_To, long double)) __d = __builtin_copysignl(__d, __sign); return __d; } #pragma GCC diagnostic pop struct _Disable_exceptions { _Disable_exceptions(basic_ostream& __os) : _M_os(__os), _M_exception(_M_os._M_exception) { _M_os._M_exception = ios_base::goodbit; } ~_Disable_exceptions() { _M_os._M_exception = _M_exception; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" _Disable_exceptions(const _Disable_exceptions&) = delete; _Disable_exceptions& operator=(const _Disable_exceptions&) = delete; #pragma GCC diagnostic pop private: basic_ostream& _M_os; const ios_base::iostate _M_exception; }; }; # 540 "/usr/include/c++/15/bits/ostream.h" 3 template class basic_ostream<_CharT, _Traits>::sentry { bool _M_ok; basic_ostream<_CharT, _Traits>& _M_os; public: # 559 "/usr/include/c++/15/bits/ostream.h" 3 explicit sentry(basic_ostream<_CharT, _Traits>& __os); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" ~sentry() { if (bool(_M_os.flags() & ios_base::unitbuf) && _M_os.good() && !uncaught_exception()) { _Disable_exceptions __noex(_M_os); try { if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) _M_os.setstate(ios_base::badbit); } catch(...) { _M_os.setstate(ios_base::badbit); } } } #pragma GCC diagnostic pop # 602 "/usr/include/c++/15/bits/ostream.h" 3 explicit operator bool() const { return _M_ok; } }; # 624 "/usr/include/c++/15/bits/ostream.h" 3 template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) { if (__out.width() != 0) return __ostream_insert(__out, &__c, 1); __out.put(__c); return __out; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) { return (__out << __out.widen(__c)); } template inline basic_ostream& operator<<(basic_ostream& __out, char __c) { if (__out.width() != 0) return __ostream_insert(__out, &__c, 1); __out.put(__c); return __out; } template inline basic_ostream& operator<<(basic_ostream& __out, signed char __c) { return (__out << static_cast(__c)); } template inline basic_ostream& operator<<(basic_ostream& __out, unsigned char __c) { return (__out << static_cast(__c)); } # 715 "/usr/include/c++/15/bits/ostream.h" 3 template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) { if (!__s) __out.setstate(ios_base::badbit); else __ostream_insert(__out, __s, static_cast(_Traits::length(__s))); return __out; } template basic_ostream<_CharT, _Traits> & operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); template inline basic_ostream& operator<<(basic_ostream& __out, const char* __s) { if (!__s) __out.setstate(ios_base::badbit); else __ostream_insert(__out, __s, static_cast(_Traits::length(__s))); return __out; } template inline basic_ostream& operator<<(basic_ostream& __out, const signed char* __s) { return (__out << reinterpret_cast(__s)); } template inline basic_ostream & operator<<(basic_ostream& __out, const unsigned char* __s) { return (__out << reinterpret_cast(__s)); } # 812 "/usr/include/c++/15/bits/ostream.h" 3 template using _Require_derived_from_ios_base = _Require, __not_>, is_convertible::type, ios_base*>>; template, typename = decltype(std::declval<_Os&>() << std::declval())> using __rvalue_stream_insertion_t = _Os&&; # 834 "/usr/include/c++/15/bits/ostream.h" 3 template inline __rvalue_stream_insertion_t<_Ostream, _Tp> operator<<(_Ostream&& __os, const _Tp& __x) { __os << __x; return std::move(__os); } } # 43 "/usr/include/c++/15/ostream" 2 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 49 "/usr/include/c++/15/ostream" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 64 "/usr/include/c++/15/ostream" 3 template inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) { return flush(__os.put(__os.widen('\n'))); } # 76 "/usr/include/c++/15/ostream" 3 template inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) { return __os.put(_CharT()); } template inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) { return __os.flush(); } # 291 "/usr/include/c++/15/ostream" 3 } # 1 "/usr/include/c++/15/bits/ostream.tcc" 1 3 # 40 "/usr/include/c++/15/bits/ostream.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template basic_ostream<_CharT, _Traits>::sentry:: sentry(basic_ostream<_CharT, _Traits>& __os) : _M_ok(false), _M_os(__os) { if (__os.tie() && __os.good()) __os.tie()->flush(); if (__os.good()) _M_ok = true; else if (__os.bad()) __os.setstate(ios_base::failbit); } template template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: _M_insert(_ValueT __v) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __num_put_type& __np = __check_facet(this->_M_num_put); if (__np.put(*this, *this, this->fill(), __v).failed()) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(short __n) { const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; if (__fmt == ios_base::oct || __fmt == ios_base::hex) return _M_insert(static_cast(static_cast(__n))); else return _M_insert(static_cast(__n)); } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(int __n) { const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; if (__fmt == ios_base::oct || __fmt == ios_base::hex) return _M_insert(static_cast(static_cast(__n))); else return _M_insert(static_cast(__n)); } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(__streambuf_type* __sbin) { ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this); if (__cerb && __sbin) { try { if (!__copy_streambufs(__sbin, this->rdbuf())) __err |= ios_base::failbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::failbit); } } else if (!__sbin) __err |= ios_base::badbit; if (__err) this->setstate(__err); return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: put(char_type __c) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __put = this->rdbuf()->sputc(__c); if (traits_type::eq_int_type(__put, traits_type::eof())) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: write(const _CharT* __s, streamsize __n) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { if (this->rdbuf()->sputn(__s, __n) != __n) __err = ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(ios_base::badbit); } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: flush() { if (__streambuf_type* __buf = this->rdbuf()) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { if (this->rdbuf()->pubsync() == -1) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } } return *this; } template typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>:: tellp() { sentry __cerb(*this); pos_type __ret = pos_type(-1); if (!this->fail()) __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); return __ret; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: seekp(pos_type __pos) { sentry __cerb(*this); if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out); if (__p == pos_type(off_type(-1))) this->setstate(ios_base::failbit); } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: seekp(off_type __off, ios_base::seekdir __dir) { sentry __cerb(*this); if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, ios_base::out); if (__p == pos_type(off_type(-1))) this->setstate(ios_base::failbit); } return *this; } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) { if (!__s) __out.setstate(ios_base::badbit); else { const size_t __clen = char_traits::length(__s); try { struct __ptr_guard { _CharT *__p; __ptr_guard (_CharT *__ip): __p(__ip) { } ~__ptr_guard() { delete[] __p; } _CharT* __get() { return __p; } } __pg (new _CharT[__clen]); _CharT *__ws = __pg.__get(); for (size_t __i = 0; __i < __clen; ++__i) __ws[__i] = __out.widen(__s[__i]); __ostream_insert(__out, __ws, __clen); } catch(__cxxabiv1::__forced_unwind&) { __out._M_setstate(ios_base::badbit); throw; } catch(...) { __out._M_setstate(ios_base::badbit); } } return __out; } extern template class basic_ostream; extern template ostream& endl(ostream&); extern template ostream& ends(ostream&); extern template ostream& flush(ostream&); extern template ostream& operator<<(ostream&, char); extern template ostream& operator<<(ostream&, unsigned char); extern template ostream& operator<<(ostream&, signed char); extern template ostream& operator<<(ostream&, const char*); extern template ostream& operator<<(ostream&, const unsigned char*); extern template ostream& operator<<(ostream&, const signed char*); extern template ostream& ostream::_M_insert(long); extern template ostream& ostream::_M_insert(unsigned long); extern template ostream& ostream::_M_insert(bool); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" extern template ostream& ostream::_M_insert(long long); extern template ostream& ostream::_M_insert(unsigned long long); #pragma GCC diagnostic pop extern template ostream& ostream::_M_insert(double); extern template ostream& ostream::_M_insert(long double); extern template ostream& ostream::_M_insert(const void*); extern template class basic_ostream; extern template wostream& endl(wostream&); extern template wostream& ends(wostream&); extern template wostream& flush(wostream&); extern template wostream& operator<<(wostream&, wchar_t); extern template wostream& operator<<(wostream&, char); extern template wostream& operator<<(wostream&, const wchar_t*); extern template wostream& operator<<(wostream&, const char*); extern template wostream& wostream::_M_insert(long); extern template wostream& wostream::_M_insert(unsigned long); extern template wostream& wostream::_M_insert(bool); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" extern template wostream& wostream::_M_insert(long long); extern template wostream& wostream::_M_insert(unsigned long long); #pragma GCC diagnostic pop extern template wostream& wostream::_M_insert(double); extern template wostream& wostream::_M_insert(long double); extern template wostream& wostream::_M_insert(const void*); } #pragma GCC diagnostic pop # 295 "/usr/include/c++/15/ostream" 2 3 # 14 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" 2 # 16 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" namespace c10 { # 36 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DeviceType.h" enum class DeviceType : int8_t { CPU = 0, CUDA = 1, MKLDNN = 2, OPENGL = 3, OPENCL = 4, IDEEP = 5, HIP = 6, FPGA = 7, MAIA = 8, XLA = 9, Vulkan = 10, Metal = 11, XPU = 12, MPS = 13, Meta = 14, HPU = 15, VE = 16, Lazy = 17, IPU = 18, MTIA = 19, PrivateUse1 = 20, COMPILE_TIME_MAX_DEVICE_TYPES = 21, }; constexpr DeviceType kCPU = DeviceType::CPU; constexpr DeviceType kCUDA = DeviceType::CUDA; constexpr DeviceType kHIP = DeviceType::HIP; constexpr DeviceType kFPGA = DeviceType::FPGA; constexpr DeviceType kMAIA = DeviceType::MAIA; constexpr DeviceType kXLA = DeviceType::XLA; constexpr DeviceType kMPS = DeviceType::MPS; constexpr DeviceType kMeta = DeviceType::Meta; constexpr DeviceType kVulkan = DeviceType::Vulkan; constexpr DeviceType kMetal = DeviceType::Metal; constexpr DeviceType kXPU = DeviceType::XPU; constexpr DeviceType kHPU = DeviceType::HPU; constexpr DeviceType kVE = DeviceType::VE; constexpr DeviceType kLazy = DeviceType::Lazy; constexpr DeviceType kIPU = DeviceType::IPU; constexpr DeviceType kMTIA = DeviceType::MTIA; constexpr DeviceType kPrivateUse1 = DeviceType::PrivateUse1; constexpr int COMPILE_TIME_MAX_DEVICE_TYPES = static_cast(DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES); static_assert( COMPILE_TIME_MAX_DEVICE_TYPES <= 21, "Hey! You seem to be adding a lot of new DeviceTypes. The intent was " "for this constant to reflect the actual number of DeviceTypes we support " "in PyTorch; it's important that this number is not too large as we " "use this to allocate stack arrays in some places in our code. If you " "are indeed just adding the 20th device type, feel free to change " "the check to 32; but if you are adding some sort of extensible device " "types registration, please be aware that you are affecting code that " "this number is small. Try auditing uses of this constant."); __attribute__((__visibility__("default"))) std::string DeviceTypeName(DeviceType d, bool lower_case = false); __attribute__((__visibility__("default"))) bool isValidDeviceType(DeviceType d); __attribute__((__visibility__("default"))) std::ostream& operator<<(std::ostream& stream, DeviceType type); __attribute__((__visibility__("default"))) void register_privateuse1_backend(const std::string& backend_name); __attribute__((__visibility__("default"))) std::string get_privateuse1_backend(bool lower_case = true); __attribute__((__visibility__("default"))) bool is_privateuse1_backend_registered(); } namespace std { template <> struct hash { std::size_t operator()(c10::DeviceType k) const { return std::hash()(static_cast(k)); } }; } namespace torch { using c10::DeviceType; } # 4 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Macros.h" 1 # 1 "/usr/include/c++/15/cassert" 1 3 # 46 "/usr/include/c++/15/cassert" 3 # 1 "/usr/include/assert.h" 1 3 4 # 47 "/usr/include/c++/15/cassert" 2 3 # 4 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Macros.h" 2 # 144 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Macros.h" namespace c10 {} namespace c10::cuda {} namespace c10::hip {} namespace c10::xpu {} namespace caffe2 { using namespace c10; } namespace at { using namespace c10; } namespace at::cuda { using namespace c10::cuda; } # 171 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Macros.h" namespace at::cuda { using namespace c10::hip; } namespace at::xpu { using namespace c10::xpu; } # 378 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Macros.h" extern "C" { # 396 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/macros/Macros.h" void __assert_fail( const char* assertion, const char* file, unsigned int line, const char* function) noexcept __attribute__((__noreturn__)); } # 5 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Array.h" 1 # 1 "/usr/include/c++/15/utility" 1 3 # 70 "/usr/include/c++/15/utility" 3 # 1 "/usr/include/c++/15/bits/stl_relops.h" 1 3 # 62 "/usr/include/c++/15/bits/stl_relops.h" 3 # 62 "/usr/include/c++/15/bits/stl_relops.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace rel_ops { # 86 "/usr/include/c++/15/bits/stl_relops.h" 3 template inline bool operator!=(const _Tp& __x, const _Tp& __y) { return !(__x == __y); } # 99 "/usr/include/c++/15/bits/stl_relops.h" 3 template inline bool operator>(const _Tp& __x, const _Tp& __y) { return __y < __x; } # 112 "/usr/include/c++/15/bits/stl_relops.h" 3 template inline bool operator<=(const _Tp& __x, const _Tp& __y) { return !(__y < __x); } # 125 "/usr/include/c++/15/bits/stl_relops.h" 3 template inline bool operator>=(const _Tp& __x, const _Tp& __y) { return !(__x < __y); } } } # 71 "/usr/include/c++/15/utility" 2 3 # 103 "/usr/include/c++/15/utility" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 104 "/usr/include/c++/15/utility" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline _Tp exchange(_Tp& __obj, _Up&& __new_val) noexcept(__and_, is_nothrow_assignable<_Tp&, _Up>>::value) { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } template [[nodiscard]] constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; } template void as_const(const _Tp&&) = delete; # 237 "/usr/include/c++/15/utility" 3 } # 5 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Array.h" 2 # 6 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Array.h" namespace c10 { template inline constexpr auto array_of(T&&... t) -> std::array { return {{std::forward(t)...}}; } } # 6 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" 2 # 1 "/usr/include/c++/15/atomic" 1 3 # 50 "/usr/include/c++/15/atomic" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 51 "/usr/include/c++/15/atomic" 2 3 # 1 "/usr/include/c++/15/bits/atomic_base.h" 1 3 # 39 "/usr/include/c++/15/bits/atomic_base.h" 3 # 1 "/usr/include/c++/15/bits/atomic_lockfree_defines.h" 1 3 # 40 "/usr/include/c++/15/bits/atomic_base.h" 2 3 # 50 "/usr/include/c++/15/bits/atomic_base.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 51 "/usr/include/c++/15/bits/atomic_base.h" 2 3 # 52 "/usr/include/c++/15/bits/atomic_base.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 82 "/usr/include/c++/15/bits/atomic_base.h" 3 enum memory_order : int { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }; enum __memory_order_modifier { __memory_order_mask = 0x0ffff, __memory_order_modifier_mask = 0xffff0000, __memory_order_hle_acquire = 0x10000, __memory_order_hle_release = 0x20000 }; constexpr memory_order operator|(memory_order __m, __memory_order_modifier __mod) noexcept { return memory_order(int(__m) | int(__mod)); } constexpr memory_order operator&(memory_order __m, __memory_order_modifier __mod) noexcept { return memory_order(int(__m) & int(__mod)); } constexpr memory_order __cmpexch_failure_order2(memory_order __m) noexcept { return __m == memory_order_acq_rel ? memory_order_acquire : __m == memory_order_release ? memory_order_relaxed : __m; } constexpr memory_order __cmpexch_failure_order(memory_order __m) noexcept { return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) | __memory_order_modifier(__m & __memory_order_modifier_mask)); } constexpr bool __is_valid_cmpexch_failure_order(memory_order __m) noexcept { return (__m & __memory_order_mask) != memory_order_release && (__m & __memory_order_mask) != memory_order_acq_rel; } template struct __atomic_base; inline __attribute__((__always_inline__)) void atomic_thread_fence(memory_order __m) noexcept { __atomic_thread_fence(int(__m)); } inline __attribute__((__always_inline__)) void atomic_signal_fence(memory_order __m) noexcept { __atomic_signal_fence(int(__m)); } template inline _Tp kill_dependency(_Tp __y) noexcept { _Tp __ret(__y); return __ret; } # 172 "/usr/include/c++/15/bits/atomic_base.h" 3 template struct atomic; template struct atomic<_Tp*>; typedef bool __atomic_flag_data_type; # 197 "/usr/include/c++/15/bits/atomic_base.h" 3 extern "C" { struct __atomic_flag_base { __atomic_flag_data_type _M_i ; }; } struct atomic_flag : public __atomic_flag_base { atomic_flag() noexcept = default; ~atomic_flag() noexcept = default; atomic_flag(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) volatile = delete; constexpr atomic_flag(bool __i) noexcept : __atomic_flag_base{ _S_init(__i) } { } inline __attribute__((__always_inline__)) bool test_and_set(memory_order __m = memory_order_seq_cst) noexcept { return __atomic_test_and_set (&_M_i, int(__m)); } inline __attribute__((__always_inline__)) bool test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_test_and_set (&_M_i, int(__m)); } # 281 "/usr/include/c++/15/bits/atomic_base.h" 3 inline __attribute__((__always_inline__)) void clear(memory_order __m = memory_order_seq_cst) noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); __atomic_clear (&_M_i, int(__m)); } inline __attribute__((__always_inline__)) void clear(memory_order __m = memory_order_seq_cst) volatile noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); __atomic_clear (&_M_i, int(__m)); } private: static constexpr __atomic_flag_data_type _S_init(bool __i) { return __i ? 1 : 0; } }; # 337 "/usr/include/c++/15/bits/atomic_base.h" 3 template struct __atomic_base { using value_type = _ITp; using difference_type = value_type; private: typedef _ITp __int_type; static constexpr int _S_alignment = sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); alignas(_S_alignment) __int_type _M_i ; public: __atomic_base() noexcept = default; ~__atomic_base() noexcept = default; __atomic_base(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } operator __int_type() const noexcept { return load(); } operator __int_type() const volatile noexcept { return load(); } __int_type operator=(__int_type __i) noexcept { store(__i); return __i; } __int_type operator=(__int_type __i) volatile noexcept { store(__i); return __i; } __int_type operator++(int) noexcept { return fetch_add(1); } __int_type operator++(int) volatile noexcept { return fetch_add(1); } __int_type operator--(int) noexcept { return fetch_sub(1); } __int_type operator--(int) volatile noexcept { return fetch_sub(1); } __int_type operator++() noexcept { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator++() volatile noexcept { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator--() noexcept { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator--() volatile noexcept { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator+=(__int_type __i) noexcept { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator+=(__int_type __i) volatile noexcept { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator-=(__int_type __i) noexcept { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator-=(__int_type __i) volatile noexcept { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator&=(__int_type __i) noexcept { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator&=(__int_type __i) volatile noexcept { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator|=(__int_type __i) noexcept { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator|=(__int_type __i) volatile noexcept { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator^=(__int_type __i) noexcept { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator^=(__int_type __i) volatile noexcept { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } bool is_lock_free() const volatile noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } inline __attribute__((__always_inline__)) void store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false); __atomic_store_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) void store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false); __atomic_store_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type load(memory_order __m = memory_order_seq_cst) const noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); return __atomic_load_n(&_M_i, int(__m)); } inline __attribute__((__always_inline__)) __int_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); return __atomic_load_n(&_M_i, int(__m)); } inline __attribute__((__always_inline__)) __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__i1, __i2, __m, __cmpexch_failure_order(__m)); } # 628 "/usr/include/c++/15/bits/atomic_base.h" 3 inline __attribute__((__always_inline__)) __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_and(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_and(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_or(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_or(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } }; template struct __atomic_base<_PTp*> { private: typedef _PTp* __pointer_type; __pointer_type _M_p ; static constexpr ptrdiff_t _S_type_size(ptrdiff_t __d) { return __d * sizeof(_PTp); } public: __atomic_base() noexcept = default; ~__atomic_base() noexcept = default; __atomic_base(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } operator __pointer_type() const noexcept { return load(); } operator __pointer_type() const volatile noexcept { return load(); } __pointer_type operator=(__pointer_type __p) noexcept { store(__p); return __p; } __pointer_type operator=(__pointer_type __p) volatile noexcept { store(__p); return __p; } __pointer_type operator++(int) noexcept { return fetch_add(1); } __pointer_type operator++(int) volatile noexcept { return fetch_add(1); } __pointer_type operator--(int) noexcept { return fetch_sub(1); } __pointer_type operator--(int) volatile noexcept { return fetch_sub(1); } __pointer_type operator++() noexcept { return __atomic_add_fetch(&_M_p, _S_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator++() volatile noexcept { return __atomic_add_fetch(&_M_p, _S_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator--() noexcept { return __atomic_sub_fetch(&_M_p, _S_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator--() volatile noexcept { return __atomic_sub_fetch(&_M_p, _S_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator+=(ptrdiff_t __d) noexcept { return __atomic_add_fetch(&_M_p, _S_type_size(__d), int(memory_order_seq_cst)); } __pointer_type operator+=(ptrdiff_t __d) volatile noexcept { return __atomic_add_fetch(&_M_p, _S_type_size(__d), int(memory_order_seq_cst)); } __pointer_type operator-=(ptrdiff_t __d) noexcept { return __atomic_sub_fetch(&_M_p, _S_type_size(__d), int(memory_order_seq_cst)); } __pointer_type operator-=(ptrdiff_t __d) volatile noexcept { return __atomic_sub_fetch(&_M_p, _S_type_size(__d), int(memory_order_seq_cst)); } bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_M_p), reinterpret_cast(-__alignof(_M_p))); } bool is_lock_free() const volatile noexcept { return __atomic_is_lock_free(sizeof(_M_p), reinterpret_cast(-__alignof(_M_p))); } inline __attribute__((__always_inline__)) void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false); __atomic_store_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false); __atomic_store_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); return __atomic_load_n(&_M_p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask; do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false); do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false); return __atomic_load_n(&_M_p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false); return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, int(__m1), int(__m2)); } # 928 "/usr/include/c++/15/bits/atomic_base.h" 3 inline __attribute__((__always_inline__)) __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_p, _S_type_size(__d), int(__m)); } inline __attribute__((__always_inline__)) __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_p, _S_type_size(__d), int(__m)); } inline __attribute__((__always_inline__)) __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_p, _S_type_size(__d), int(__m)); } inline __attribute__((__always_inline__)) __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_p, _S_type_size(__d), int(__m)); } }; namespace __atomic_impl { template constexpr bool __maybe_has_padding() { return !__has_unique_object_representations(_Tp) && !is_same<_Tp, float>::value && !is_same<_Tp, double>::value; } template inline __attribute__((__always_inline__)) constexpr _Tp* __clear_padding(_Tp& __val) noexcept { auto* __ptr = std::__addressof(__val); if constexpr (__atomic_impl::__maybe_has_padding<_Tp>()) __builtin_clear_padding(__ptr); return __ptr; } template using _Val = typename remove_volatile<_Tp>::type; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template inline __attribute__((__always_inline__)) bool __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i, bool __is_weak, memory_order __s, memory_order __f) noexcept { do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__f))) std::__glibcxx_assert_fail(); } while (false); using _Vp = _Val<_Tp>; _Tp* const __pval = std::__addressof(__val); if constexpr (!__atomic_impl::__maybe_has_padding<_Vp>()) { return __atomic_compare_exchange(__pval, std::__addressof(__e), std::__addressof(__i), __is_weak, int(__s), int(__f)); } else if constexpr (!_AtomicRef) { _Vp* const __pi = __atomic_impl::__clear_padding(__i); _Vp __exp = __e; _Vp* const __pexp = __atomic_impl::__clear_padding(__exp); if (__atomic_compare_exchange(__pval, __pexp, __pi, __is_weak, int(__s), int(__f))) return true; __builtin_memcpy(std::__addressof(__e), __pexp, sizeof(_Vp)); return false; } else { _Vp* const __pi = __atomic_impl::__clear_padding(__i); _Vp __exp = __e; _Vp* const __pexp = __atomic_impl::__clear_padding(__exp); # 1042 "/usr/include/c++/15/bits/atomic_base.h" 3 while (true) { _Vp __orig = __exp; if (__atomic_compare_exchange(__pval, __pexp, __pi, __is_weak, int(__s), int(__f))) return true; _Vp __curr = __exp; if (__builtin_memcmp(__atomic_impl::__clear_padding(__orig), __atomic_impl::__clear_padding(__curr), sizeof(_Vp))) { __builtin_memcpy(std::__addressof(__e), __pexp, sizeof(_Vp)); return false; } } } } #pragma GCC diagnostic pop } # 2105 "/usr/include/c++/15/bits/atomic_base.h" 3 } # 53 "/usr/include/c++/15/atomic" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct atomic; template<> struct atomic { using value_type = bool; private: __atomic_base _M_base; public: atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(bool __i) noexcept : _M_base(__i) { } bool operator=(bool __i) noexcept { return _M_base.operator=(__i); } bool operator=(bool __i) volatile noexcept { return _M_base.operator=(__i); } operator bool() const noexcept { return _M_base.load(); } operator bool() const volatile noexcept { return _M_base.load(); } bool is_lock_free() const noexcept { return _M_base.is_lock_free(); } bool is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } static constexpr bool is_always_lock_free = 2 == 2; void store(bool __i, memory_order __m = memory_order_seq_cst) noexcept { _M_base.store(__i, __m); } void store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { _M_base.store(__i, __m); } bool load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_base.load(__m); } bool load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_base.load(__m); } bool exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.exchange(__i, __m); } bool exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.exchange(__i, __m); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } # 191 "/usr/include/c++/15/atomic" 3 }; template struct atomic { using value_type = _Tp; private: static constexpr int _S_min_alignment = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 ? 0 : sizeof(_Tp); static constexpr int _S_alignment = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); alignas(_S_alignment) _Tp _M_i; static_assert(__is_trivially_copyable(_Tp), "std::atomic requires a trivially copyable type"); static_assert(sizeof(_Tp) > 0, "Incomplete or zero-sized types are not supported"); # 227 "/usr/include/c++/15/atomic" 3 public: # 236 "/usr/include/c++/15/atomic" 3 atomic() = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(_Tp __i) noexcept : _M_i(__i) { if constexpr (__atomic_impl::__maybe_has_padding<_Tp>()) __builtin_clear_padding(std::__addressof(_M_i)); } operator _Tp() const noexcept { return load(); } operator _Tp() const volatile noexcept { return load(); } _Tp operator=(_Tp __i) noexcept { store(__i); return __i; } _Tp operator=(_Tp __i) volatile noexcept { store(__i); return __i; } bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } bool is_lock_free() const volatile noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_M_i), 0); void store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept { __atomic_store(std::__addressof(_M_i), __atomic_impl::__clear_padding(__i), int(__m)); } void store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { __atomic_store(std::__addressof(_M_i), __atomic_impl::__clear_padding(__i), int(__m)); } _Tp load(memory_order __m = memory_order_seq_cst) const noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); return *__ptr; } _Tp load(memory_order __m = memory_order_seq_cst) const volatile noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); return *__ptr; } _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_exchange(std::__addressof(_M_i), __atomic_impl::__clear_padding(__i), __ptr, int(__m)); return *__ptr; } _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_exchange(std::__addressof(_M_i), __atomic_impl::__clear_padding(__i), __ptr, int(__m)); return *__ptr; } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_impl::__compare_exchange(_M_i, __e, __i, true, __s, __f); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_impl::__compare_exchange(_M_i, __e, __i, true, __s, __f); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__e, __i, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__e, __i, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_impl::__compare_exchange(_M_i, __e, __i, false, __s, __f); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_impl::__compare_exchange(_M_i, __e, __i, false, __s, __f); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__e, __i, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__e, __i, __m, __cmpexch_failure_order(__m)); } # 419 "/usr/include/c++/15/atomic" 3 }; template struct atomic<_Tp*> { using value_type = _Tp*; using difference_type = ptrdiff_t; typedef _Tp* __pointer_type; typedef __atomic_base<_Tp*> __base_type; __base_type _M_b; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } operator __pointer_type() const noexcept { return __pointer_type(_M_b); } operator __pointer_type() const volatile noexcept { return __pointer_type(_M_b); } __pointer_type operator=(__pointer_type __p) noexcept { return _M_b.operator=(__p); } __pointer_type operator=(__pointer_type __p) volatile noexcept { return _M_b.operator=(__p); } __pointer_type operator++(int) noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b++; } __pointer_type operator++(int) volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b++; } __pointer_type operator--(int) noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b--; } __pointer_type operator--(int) volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b--; } __pointer_type operator++() noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return ++_M_b; } __pointer_type operator++() volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return ++_M_b; } __pointer_type operator--() noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return --_M_b; } __pointer_type operator--() volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return --_M_b; } __pointer_type operator+=(ptrdiff_t __d) noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.operator+=(__d); } __pointer_type operator+=(ptrdiff_t __d) volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.operator+=(__d); } __pointer_type operator-=(ptrdiff_t __d) noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.operator-=(__d); } __pointer_type operator-=(ptrdiff_t __d) volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.operator-=(__d); } bool is_lock_free() const noexcept { return _M_b.is_lock_free(); } bool is_lock_free() const volatile noexcept { return _M_b.is_lock_free(); } static constexpr bool is_always_lock_free = 2 == 2; void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.store(__p, __m); } void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.store(__p, __m); } __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_b.load(__m); } __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_b.load(__m); } __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.exchange(__p, __m); } __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.exchange(__p, __m); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__p1, __p2, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__p1, __p2, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m, __cmpexch_failure_order(__m)); } # 673 "/usr/include/c++/15/atomic" 3 __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.fetch_add(__d, __m); } __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.fetch_add(__d, __m); } __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.fetch_sub(__d, __m); } __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { static_assert( is_object_v<_Tp>, "pointer to object type" ); return _M_b.fetch_sub(__d, __m); } }; template<> struct atomic : __atomic_base { typedef char __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef signed char __integral_type; typedef __atomic_base __base_type; atomic() noexcept= default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned char __integral_type; typedef __atomic_base __base_type; atomic() noexcept= default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef short __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned short __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef int __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned int __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef long long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned long long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef wchar_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; # 1018 "/usr/include/c++/15/atomic" 3 template<> struct atomic : __atomic_base { typedef char16_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef char32_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; typedef atomic atomic_bool; typedef atomic atomic_char; typedef atomic atomic_schar; typedef atomic atomic_uchar; typedef atomic atomic_short; typedef atomic atomic_ushort; typedef atomic atomic_int; typedef atomic atomic_uint; typedef atomic atomic_long; typedef atomic atomic_ulong; typedef atomic atomic_llong; typedef atomic atomic_ullong; typedef atomic atomic_wchar_t; typedef atomic atomic_char16_t; typedef atomic atomic_char32_t; typedef atomic atomic_int8_t; typedef atomic atomic_uint8_t; typedef atomic atomic_int16_t; typedef atomic atomic_uint16_t; typedef atomic atomic_int32_t; typedef atomic atomic_uint32_t; typedef atomic atomic_int64_t; typedef atomic atomic_uint64_t; typedef atomic atomic_int_least8_t; typedef atomic atomic_uint_least8_t; typedef atomic atomic_int_least16_t; typedef atomic atomic_uint_least16_t; typedef atomic atomic_int_least32_t; typedef atomic atomic_uint_least32_t; typedef atomic atomic_int_least64_t; typedef atomic atomic_uint_least64_t; typedef atomic atomic_int_fast8_t; typedef atomic atomic_uint_fast8_t; typedef atomic atomic_int_fast16_t; typedef atomic atomic_uint_fast16_t; typedef atomic atomic_int_fast32_t; typedef atomic atomic_uint_fast32_t; typedef atomic atomic_int_fast64_t; typedef atomic atomic_uint_fast64_t; typedef atomic atomic_intptr_t; typedef atomic atomic_uintptr_t; typedef atomic atomic_size_t; typedef atomic atomic_ptrdiff_t; typedef atomic atomic_intmax_t; typedef atomic atomic_uintmax_t; inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } # 1244 "/usr/include/c++/15/atomic" 3 inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } # 1291 "/usr/include/c++/15/atomic" 3 template using __atomic_val_t = __type_identity_t<_Tp>; template using __atomic_diff_t = typename atomic<_Tp>::difference_type; template inline bool atomic_is_lock_free(const atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template inline bool atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template inline void atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { __a->store(__i, memory_order_relaxed); } template inline void atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { __a->store(__i, memory_order_relaxed); } template inline void atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { __a->store(__i, __m); } template inline void atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { __a->store(__i, __m); } template inline _ITp atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template inline _ITp atomic_load_explicit(const volatile atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template inline _ITp atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template inline _ITp atomic_exchange_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template inline bool atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template inline bool atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template inline bool atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template inline bool atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template inline void atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template inline void atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_load(const atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template inline _ITp atomic_load(const volatile atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template inline _ITp atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_exchange(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_strong(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } # 1497 "/usr/include/c++/15/atomic" 3 template inline _ITp atomic_fetch_add_explicit(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template inline _ITp atomic_fetch_add_explicit(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template inline _ITp atomic_fetch_sub_explicit(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template inline _ITp atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template inline _ITp atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template inline _ITp atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template inline _ITp atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template inline _ITp atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template inline _ITp atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template inline _ITp atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template inline _ITp atomic_fetch_add(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_add(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_sub(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_sub(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_and(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_and(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_or(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_or(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_xor(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } # 1798 "/usr/include/c++/15/atomic" 3 } # 8 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" 2 # 1 "/usr/include/c++/15/variant" 1 3 # 39 "/usr/include/c++/15/variant" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 40 "/usr/include/c++/15/variant" 2 3 # 48 "/usr/include/c++/15/variant" 3 # 1 "/usr/include/c++/15/bits/monostate.h" 1 3 # 33 "/usr/include/c++/15/bits/monostate.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 34 "/usr/include/c++/15/bits/monostate.h" 2 3 # 42 "/usr/include/c++/15/bits/monostate.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct monostate { }; constexpr bool operator==(monostate, monostate) noexcept { return true; } constexpr bool operator!=(monostate, monostate) noexcept { return false; } constexpr bool operator<(monostate, monostate) noexcept { return false; } constexpr bool operator>(monostate, monostate) noexcept { return false; } constexpr bool operator<=(monostate, monostate) noexcept { return true; } constexpr bool operator>=(monostate, monostate) noexcept { return true; } template<> struct hash { using result_type [[__deprecated__]] = size_t; using argument_type [[__deprecated__]] = monostate; size_t operator()(const monostate&) const noexcept { constexpr size_t __magic_monostate_hash = -7777; return __magic_monostate_hash; } }; } # 49 "/usr/include/c++/15/variant" 2 3 # 1 "/usr/include/c++/15/bits/parse_numbers.h" 1 3 # 44 "/usr/include/c++/15/bits/parse_numbers.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __parse_int { template struct _Digit; template struct _Digit<_Base, '0'> : integral_constant { using __valid = true_type; }; template struct _Digit<_Base, '1'> : integral_constant { using __valid = true_type; }; template struct _Digit_impl : integral_constant { static_assert(_Base > _Val, "invalid digit"); using __valid = true_type; }; template struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2> { }; template struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3> { }; template struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4> { }; template struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5> { }; template struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6> { }; template struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7> { }; template struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8> { }; template struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9> { }; template struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa> { }; template struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa> { }; template struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb> { }; template struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb> { }; template struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc> { }; template struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc> { }; template struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd> { }; template struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd> { }; template struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe> { }; template struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe> { }; template struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf> { }; template struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf> { }; template struct _Digit<_Base, '\''> : integral_constant { using __valid = false_type; }; template using __ull_constant = integral_constant; template struct _Power_help { using __next = typename _Power_help<_Base, _Digs...>::type; using __valid_digit = typename _Digit<_Base, _Dig>::__valid; using type = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>; }; template struct _Power_help<_Base, _Dig> { using __valid_digit = typename _Digit<_Base, _Dig>::__valid; using type = __ull_constant<__valid_digit::value>; }; template struct _Power : _Power_help<_Base, _Digs...>::type { }; template struct _Power<_Base> : __ull_constant<0> { }; template struct _Number_help { using __digit = _Digit<_Base, _Dig>; using __valid_digit = typename __digit::__valid; using __next = _Number_help<_Base, __valid_digit::value ? _Pow / _Base : _Pow, _Digs...>; using type = __ull_constant<_Pow * __digit::value + __next::type::value>; static_assert((type::value / _Pow) == __digit::value, "integer literal does not fit in unsigned long long"); }; template struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...> : _Number_help<_Base, _Pow, _Dig, _Digs...> { }; template struct _Number_help<_Base, 1ULL, _Dig> { using type = __ull_constant<_Digit<_Base, _Dig>::value>; }; template struct _Number : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type { }; template struct _Number<_Base> : __ull_constant<0> { }; template struct _Parse_int; template struct _Parse_int<'0', 'b', _Digs...> : _Number<2U, _Digs...>::type { }; template struct _Parse_int<'0', 'B', _Digs...> : _Number<2U, _Digs...>::type { }; template struct _Parse_int<'0', 'x', _Digs...> : _Number<16U, _Digs...>::type { }; template struct _Parse_int<'0', 'X', _Digs...> : _Number<16U, _Digs...>::type { }; template struct _Parse_int<'0', _Digs...> : _Number<8U, _Digs...>::type { }; template struct _Parse_int : _Number<10U, _Digs...>::type { }; } namespace __select_int { template struct _Select_int_base; template struct _Select_int_base<_Val, _IntType, _Ints...> : __conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max), integral_constant<_IntType, (_IntType)_Val>, _Select_int_base<_Val, _Ints...>> { }; template struct _Select_int_base<_Val> { }; template using _Select_int = typename _Select_int_base< __parse_int::_Parse_int<_Digs...>::value, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long >::type; } } # 50 "/usr/include/c++/15/variant" 2 3 # 63 "/usr/include/c++/15/variant" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class tuple; template class variant; template struct variant_size; template struct variant_size : variant_size<_Variant> {}; template struct variant_size : variant_size<_Variant> {}; template struct variant_size : variant_size<_Variant> {}; template struct variant_size> : std::integral_constant {}; template inline constexpr size_t variant_size_v = variant_size<_Variant>::value; template inline constexpr size_t variant_size_v> = sizeof...(_Types); template inline constexpr size_t variant_size_v> = sizeof...(_Types); template struct variant_alternative; template struct variant_alternative<_Np, variant<_Types...>> { static_assert(_Np < sizeof...(_Types)); using type = typename _Nth_type<_Np, _Types...>::type; }; template using variant_alternative_t = typename variant_alternative<_Np, _Variant>::type; template struct variant_alternative<_Np, const _Variant> { using type = const variant_alternative_t<_Np, _Variant>; }; template struct variant_alternative<_Np, volatile _Variant> { using type = volatile variant_alternative_t<_Np, _Variant>; }; template struct variant_alternative<_Np, const volatile _Variant> { using type = const volatile variant_alternative_t<_Np, _Variant>; }; inline constexpr size_t variant_npos = -1; template constexpr variant_alternative_t<_Np, variant<_Types...>>& get(variant<_Types...>&); template constexpr variant_alternative_t<_Np, variant<_Types...>>&& get(variant<_Types...>&&); template constexpr variant_alternative_t<_Np, variant<_Types...>> const& get(const variant<_Types...>&); template constexpr variant_alternative_t<_Np, variant<_Types...>> const&& get(const variant<_Types...>&&); template constexpr decltype(auto) __do_visit(_Visitor&& __visitor, _Variants&&... __variants); template decltype(auto) __variant_cast(_Tp&& __rhs) { if constexpr (is_lvalue_reference_v<_Tp>) { if constexpr (is_const_v>) return static_cast&>(__rhs); else return static_cast&>(__rhs); } else return static_cast&&>(__rhs); } namespace __detail { namespace __variant { struct __variant_cookie {}; struct __variant_idx_cookie { using type = __variant_idx_cookie; }; template struct __deduce_visit_result { using type = _Tp; }; template constexpr void __raw_visit(_Visitor&& __visitor, _Variants&&... __variants) { std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } template constexpr void __raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants) { std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } template constexpr std::variant<_Types...>& __as(std::variant<_Types...>& __v) noexcept { return __v; } template constexpr const std::variant<_Types...>& __as(const std::variant<_Types...>& __v) noexcept { return __v; } template constexpr std::variant<_Types...>&& __as(std::variant<_Types...>&& __v) noexcept { return std::move(__v); } template constexpr const std::variant<_Types...>&& __as(const std::variant<_Types...>&& __v) noexcept { return std::move(__v); } template> struct _Uninitialized; template struct _Uninitialized { template constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args) : _M_storage(std::forward<_Args>(__args)...) { } constexpr const _Type& _M_get() const & noexcept { return _M_storage; } constexpr _Type& _M_get() & noexcept { return _M_storage; } constexpr const _Type&& _M_get() const && noexcept { return std::move(_M_storage); } constexpr _Type&& _M_get() && noexcept { return std::move(_M_storage); } _Type _M_storage; }; template struct _Uninitialized<_Type, false> { template constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args) { ::new ((void*)std::addressof(_M_storage)) _Type(std::forward<_Args>(__args)...); } const _Type& _M_get() const & noexcept { return *_M_storage._M_ptr(); } _Type& _M_get() & noexcept { return *_M_storage._M_ptr(); } const _Type&& _M_get() const && noexcept { return std::move(*_M_storage._M_ptr()); } _Type&& _M_get() && noexcept { return std::move(*_M_storage._M_ptr()); } __gnu_cxx::__aligned_membuf<_Type> _M_storage; }; template constexpr decltype(auto) __get_n(_Union&& __u) noexcept { if constexpr (_Np == 0) return std::forward<_Union>(__u)._M_first._M_get(); else if constexpr (_Np == 1) return std::forward<_Union>(__u)._M_rest._M_first._M_get(); else if constexpr (_Np == 2) return std::forward<_Union>(__u)._M_rest._M_rest._M_first._M_get(); else return __variant::__get_n<_Np - 3>( std::forward<_Union>(__u)._M_rest._M_rest._M_rest); } # 311 "/usr/include/c++/15/variant" 3 template constexpr decltype(auto) __get(_Variant&& __v) noexcept { return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); } template constexpr decltype(auto) __construct_n(_Union& __u) noexcept { if constexpr (_Np == 0) return &__u._M_first; else if constexpr (_Np == 1) { std::_Construct(&__u._M_rest); return &__u._M_rest._M_first; } else if constexpr (_Np == 2) { std::_Construct(&__u._M_rest); std::_Construct(&__u._M_rest._M_rest); return &__u._M_rest._M_rest._M_first; } else { std::_Construct(&__u._M_rest); std::_Construct(&__u._M_rest._M_rest); std::_Construct(&__u._M_rest._M_rest._M_rest); return __variant::__construct_n<_Np - 3>(__u._M_rest._M_rest._M_rest); } } template struct _Traits { static constexpr bool _S_default_ctor = is_default_constructible_v::type>; static constexpr bool _S_copy_ctor = (is_copy_constructible_v<_Types> && ...); static constexpr bool _S_move_ctor = (is_move_constructible_v<_Types> && ...); static constexpr bool _S_copy_assign = _S_copy_ctor && (is_copy_assignable_v<_Types> && ...); static constexpr bool _S_move_assign = _S_move_ctor && (is_move_assignable_v<_Types> && ...); static constexpr bool _S_trivial_dtor = (is_trivially_destructible_v<_Types> && ...); static constexpr bool _S_trivial_copy_ctor = (is_trivially_copy_constructible_v<_Types> && ...); static constexpr bool _S_trivial_move_ctor = (is_trivially_move_constructible_v<_Types> && ...); static constexpr bool _S_trivial_copy_assign = _S_trivial_dtor && _S_trivial_copy_ctor && (is_trivially_copy_assignable_v<_Types> && ...); static constexpr bool _S_trivial_move_assign = _S_trivial_dtor && _S_trivial_move_ctor && (is_trivially_move_assignable_v<_Types> && ...); static constexpr bool _S_nothrow_default_ctor = is_nothrow_default_constructible_v< typename _Nth_type<0, _Types...>::type>; static constexpr bool _S_nothrow_copy_ctor = false; static constexpr bool _S_nothrow_move_ctor = (is_nothrow_move_constructible_v<_Types> && ...); static constexpr bool _S_nothrow_copy_assign = false; static constexpr bool _S_nothrow_move_assign = _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...); }; template union _Variadic_union { _Variadic_union() = default; template _Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete; }; template union _Variadic_union<__trivially_destructible, _First, _Rest...> { constexpr _Variadic_union() : _M_rest() { } template constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args) : _M_first(in_place_index<0>, std::forward<_Args>(__args)...) { } template constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args) : _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...) { } # 429 "/usr/include/c++/15/variant" 3 _Uninitialized<_First> _M_first; _Variadic_union<__trivially_destructible, _Rest...> _M_rest; }; template struct _Never_valueless_alt : __and_, is_trivially_copyable<_Tp>> { }; # 453 "/usr/include/c++/15/variant" 3 template constexpr bool __never_valueless() { return _Traits<_Types...>::_S_move_assign && (_Never_valueless_alt<_Types>::value && ...); } template struct _Variant_storage; template using __select_index = typename __select_int::_Select_int_base::type::value_type; template struct _Variant_storage { constexpr _Variant_storage() : _M_index(static_cast<__index_type>(variant_npos)) { } template constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), _M_index{_Np} { } constexpr void _M_reset() { if (!_M_valid()) [[__unlikely__]] return; std::__do_visit([](auto&& __this_mem) mutable { std::_Destroy(std::__addressof(__this_mem)); }, __variant_cast<_Types...>(*this)); _M_index = static_cast<__index_type>(variant_npos); } ~_Variant_storage() { _M_reset(); } constexpr bool _M_valid() const noexcept { if constexpr (__variant::__never_valueless<_Types...>()) return true; return this->_M_index != __index_type(variant_npos); } _Variadic_union _M_u; using __index_type = __select_index<_Types...>; __index_type _M_index; }; template struct _Variant_storage { constexpr _Variant_storage() : _M_index(static_cast<__index_type>(variant_npos)) { } template constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), _M_index{_Np} { } constexpr void _M_reset() noexcept { _M_index = static_cast<__index_type>(variant_npos); } constexpr bool _M_valid() const noexcept { if constexpr (__variant::__never_valueless<_Types...>()) return true; return this->_M_index != static_cast<__index_type>(variant_npos); } _Variadic_union _M_u; using __index_type = __select_index<_Types...>; __index_type _M_index; }; template inline void __emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args) { __v._M_reset(); auto* __addr = __variant::__construct_n<_Np>(__v._M_u); std::_Construct(__addr, in_place_index<0>, std::forward<_Args>(__args)...); __v._M_index = _Np; } template using _Variant_storage_alias = _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>; template struct _Copy_ctor_base : _Variant_storage_alias<_Types...> { using _Base = _Variant_storage_alias<_Types...>; using _Base::_Base; _Copy_ctor_base(const _Copy_ctor_base& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) std::_Construct(std::__addressof(this->_M_u), in_place_index<__j>, __rhs_mem); }, __variant_cast<_Types...>(__rhs)); this->_M_index = __rhs._M_index; } _Copy_ctor_base(_Copy_ctor_base&&) = default; _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default; _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default; }; template struct _Copy_ctor_base : _Variant_storage_alias<_Types...> { using _Base = _Variant_storage_alias<_Types...>; using _Base::_Base; }; template using _Copy_ctor_alias = _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>; template struct _Move_ctor_base : _Copy_ctor_alias<_Types...> { using _Base = _Copy_ctor_alias<_Types...>; using _Base::_Base; _Move_ctor_base(_Move_ctor_base&& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_move_ctor) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) std::_Construct(std::__addressof(this->_M_u), in_place_index<__j>, std::forward(__rhs_mem)); }, __variant_cast<_Types...>(std::move(__rhs))); this->_M_index = __rhs._M_index; } _Move_ctor_base(const _Move_ctor_base&) = default; _Move_ctor_base& operator=(const _Move_ctor_base&) = default; _Move_ctor_base& operator=(_Move_ctor_base&&) = default; }; template struct _Move_ctor_base : _Copy_ctor_alias<_Types...> { using _Base = _Copy_ctor_alias<_Types...>; using _Base::_Base; }; template using _Move_ctor_alias = _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>; template struct _Copy_assign_base : _Move_ctor_alias<_Types...> { using _Base = _Move_ctor_alias<_Types...>; using _Base::_Base; _Copy_assign_base& operator=(const _Copy_assign_base& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_copy_assign) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j == variant_npos) this->_M_reset(); else if (this->_M_index == __j) __variant::__get<__j>(*this) = __rhs_mem; else { using _Tj = typename _Nth_type<__j, _Types...>::type; if constexpr (is_nothrow_copy_constructible_v<_Tj> || !is_nothrow_move_constructible_v<_Tj>) __variant::__emplace<__j>(*this, __rhs_mem); else { using _Variant = variant<_Types...>; _Variant& __self = __variant_cast<_Types...>(*this); __self = _Variant(in_place_index<__j>, __rhs_mem); } } }, __variant_cast<_Types...>(__rhs)); return *this; } _Copy_assign_base(const _Copy_assign_base&) = default; _Copy_assign_base(_Copy_assign_base&&) = default; _Copy_assign_base& operator=(_Copy_assign_base&&) = default; }; template struct _Copy_assign_base : _Move_ctor_alias<_Types...> { using _Base = _Move_ctor_alias<_Types...>; using _Base::_Base; }; template using _Copy_assign_alias = _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>; template struct _Move_assign_base : _Copy_assign_alias<_Types...> { using _Base = _Copy_assign_alias<_Types...>; using _Base::_Base; _Move_assign_base& operator=(_Move_assign_base&& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_move_assign) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) { if (this->_M_index == __j) __variant::__get<__j>(*this) = std::move(__rhs_mem); else { using _Tj = typename _Nth_type<__j, _Types...>::type; if constexpr (is_nothrow_move_constructible_v<_Tj>) __variant::__emplace<__j>(*this, std::move(__rhs_mem)); else { using _Variant = variant<_Types...>; _Variant& __self = __variant_cast<_Types...>(*this); __self.template emplace<__j>(std::move(__rhs_mem)); } } } else this->_M_reset(); }, __variant_cast<_Types...>(__rhs)); return *this; } _Move_assign_base(const _Move_assign_base&) = default; _Move_assign_base(_Move_assign_base&&) = default; _Move_assign_base& operator=(const _Move_assign_base&) = default; }; template struct _Move_assign_base : _Copy_assign_alias<_Types...> { using _Base = _Copy_assign_alias<_Types...>; using _Base::_Base; }; template using _Move_assign_alias = _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>; template struct _Variant_base : _Move_assign_alias<_Types...> { using _Base = _Move_assign_alias<_Types...>; constexpr _Variant_base() noexcept(_Traits<_Types...>::_S_nothrow_default_ctor) : _Variant_base(in_place_index<0>) { } template constexpr explicit _Variant_base(in_place_index_t<_Np> __i, _Args&&... __args) : _Base(__i, std::forward<_Args>(__args)...) { } _Variant_base(const _Variant_base&) = default; _Variant_base(_Variant_base&&) = default; _Variant_base& operator=(const _Variant_base&) = default; _Variant_base& operator=(_Variant_base&&) = default; }; template inline constexpr bool __exactly_once = std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Types); template struct _Arr { _Ti _M_x[1]; }; template struct _Build_FUN { void _S_fun() = delete; }; template struct _Build_FUN<_Ind, _Tp, _Ti, void_t{{std::declval<_Tp>()}})>> { static integral_constant _S_fun(_Ti); }; template>> struct _Build_FUNs; template struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>> : _Build_FUN<_Ind, _Tp, _Ti>... { using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...; }; template using _FUN_type = decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>())); template inline constexpr size_t __accepted_index = variant_npos; template inline constexpr size_t __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>> = _FUN_type<_Tp, _Variant>::value; template> inline constexpr bool __extra_visit_slot_needed = false; template inline constexpr bool __extra_visit_slot_needed<__variant_cookie, _Var, variant<_Types...>> = !__variant::__never_valueless<_Types...>(); template inline constexpr bool __extra_visit_slot_needed<__variant_idx_cookie, _Var, variant<_Types...>> = !__variant::__never_valueless<_Types...>(); template struct _Multi_array; template struct _Multi_array<_Tp> { template struct __untag_result : false_type { using element_type = _Tp; }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wignored-qualifiers" template struct __untag_result : false_type { using element_type = void(*)(_Args...); }; #pragma GCC diagnostic pop template struct __untag_result<__variant_cookie(*)(_Args...)> : false_type { using element_type = void(*)(_Args...); }; template struct __untag_result<__variant_idx_cookie(*)(_Args...)> : false_type { using element_type = void(*)(_Args...); }; template struct __untag_result<__deduce_visit_result<_Res>(*)(_Args...)> : true_type { using element_type = _Res(*)(_Args...); }; using __result_is_deduced = __untag_result<_Tp>; constexpr const typename __untag_result<_Tp>::element_type& _M_access() const { return _M_data; } typename __untag_result<_Tp>::element_type _M_data; }; template struct _Multi_array<_Ret(*)(_Visitor, _Variants...), __first, __rest...> { static constexpr size_t __index = sizeof...(_Variants) - sizeof...(__rest) - 1; using _Variant = typename _Nth_type<__index, _Variants...>::type; static constexpr int __do_cookie = __extra_visit_slot_needed<_Ret, _Variant> ? 1 : 0; using _Tp = _Ret(*)(_Visitor, _Variants...); template constexpr decltype(auto) _M_access(size_t __first_index, _Args... __rest_indices) const { return _M_arr[__first_index + __do_cookie] ._M_access(__rest_indices...); } _Multi_array<_Tp, __rest...> _M_arr[__first + __do_cookie]; }; # 944 "/usr/include/c++/15/variant" 3 template struct __gen_vtable_impl; # 954 "/usr/include/c++/15/variant" 3 template struct __gen_vtable_impl< _Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>, std::index_sequence<__indices...>> { using _Next = remove_reference_t::type>; using _Array_type = _Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>; static constexpr _Array_type _S_apply() { _Array_type __vtable{}; _S_apply_all_alts( __vtable, make_index_sequence>()); return __vtable; } template static constexpr void _S_apply_all_alts(_Array_type& __vtable, std::index_sequence<__var_indices...>) { if constexpr (__extra_visit_slot_needed<_Result_type, _Next>) (_S_apply_single_alt( __vtable._M_arr[__var_indices + 1], &(__vtable._M_arr[0])), ...); else (_S_apply_single_alt( __vtable._M_arr[__var_indices]), ...); } template static constexpr void _S_apply_single_alt(_Tp& __element, _Tp* __cookie_element = nullptr) { if constexpr (__do_cookie) { __element = __gen_vtable_impl< _Tp, std::index_sequence<__indices..., __index>>::_S_apply(); *__cookie_element = __gen_vtable_impl< _Tp, std::index_sequence<__indices..., variant_npos>>::_S_apply(); } else { auto __tmp_element = __gen_vtable_impl< remove_reference_t, std::index_sequence<__indices..., __index>>::_S_apply(); static_assert(is_same_v<_Tp, decltype(__tmp_element)>, "std::visit requires the visitor to have the same " "return type for all alternatives of a variant"); __element = __tmp_element; } } }; template struct __gen_vtable_impl< _Multi_array<_Result_type (*)(_Visitor, _Variants...)>, std::index_sequence<__indices...>> { using _Array_type = _Multi_array<_Result_type (*)(_Visitor, _Variants...)>; template static constexpr decltype(auto) __element_by_index_or_cookie(_Variant&& __var) noexcept { if constexpr (__index != variant_npos) return __variant::__get<__index>(std::forward<_Variant>(__var)); else return __variant_cookie{}; } static constexpr decltype(auto) __visit_invoke(_Visitor&& __visitor, _Variants... __vars) { if constexpr (is_same_v<_Result_type, __variant_idx_cookie>) std::__invoke(std::forward<_Visitor>(__visitor), __element_by_index_or_cookie<__indices>( std::forward<_Variants>(__vars))..., integral_constant()...); else if constexpr (is_same_v<_Result_type, __variant_cookie>) std::__invoke(std::forward<_Visitor>(__visitor), __element_by_index_or_cookie<__indices>( std::forward<_Variants>(__vars))...); else if constexpr (_Array_type::__result_is_deduced::value) return std::__invoke(std::forward<_Visitor>(__visitor), __element_by_index_or_cookie<__indices>( std::forward<_Variants>(__vars))...); else return std::__invoke_r<_Result_type>( std::forward<_Visitor>(__visitor), __variant::__get<__indices>(std::forward<_Variants>(__vars))...); } static constexpr auto _S_apply() { if constexpr (_Array_type::__result_is_deduced::value) { constexpr bool __visit_ret_type_mismatch = !is_same_v(), std::declval<_Variants>()...))>; if constexpr (__visit_ret_type_mismatch) { struct __cannot_match {}; return __cannot_match{}; } else return _Array_type{&__visit_invoke}; } else return _Array_type{&__visit_invoke}; } }; template struct __gen_vtable { using _Array_type = _Multi_array<_Result_type (*)(_Visitor, _Variants...), variant_size_v>...>; static constexpr _Array_type _S_vtable = __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply(); }; template struct _Base_dedup : public _Tp { }; template struct _Variant_hash_base; template struct _Variant_hash_base, std::index_sequence<__indices...>> : _Base_dedup<__indices, __hash_empty_base>>... { }; template())), typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>> using __get_t = __conditional_t, _Tp&, _Tp&&>; template using __visit_result_t = invoke_result_t<_Visitor, __get_t<0, _Variants>...>; template constexpr inline bool __same_types = (is_same_v<_Tp, _Types> && ...); template constexpr bool __check_visitor_results(std::index_sequence<_Idxs...>) { return __same_types< invoke_result_t<_Visitor, __get_t<_Idxs, _Variant>>... >; } } } template constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); return __v.index() == std::__find_uniq_type_in_pack<_Tp, _Types...>(); } template constexpr _Tp& get(variant<_Types...>& __v) { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); return std::get<__n>(__v); } template constexpr _Tp&& get(variant<_Types...>&& __v) { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); return std::get<__n>(std::move(__v)); } template constexpr const _Tp& get(const variant<_Types...>& __v) { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); return std::get<__n>(__v); } template constexpr const _Tp&& get(const variant<_Types...>&& __v) { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); return std::get<__n>(std::move(__v)); } template constexpr add_pointer_t>> get_if(variant<_Types...>* __ptr) noexcept { using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>; static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void"); if (__ptr && __ptr->index() == _Np) return std::addressof(__detail::__variant::__get<_Np>(*__ptr)); return nullptr; } template constexpr add_pointer_t>> get_if(const variant<_Types...>* __ptr) noexcept { using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>; static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void"); if (__ptr && __ptr->index() == _Np) return std::addressof(__detail::__variant::__get<_Np>(*__ptr)); return nullptr; } template constexpr add_pointer_t<_Tp> get_if(variant<_Types...>* __ptr) noexcept { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); static_assert(!is_void_v<_Tp>, "_Tp must not be void"); constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); return std::get_if<__n>(__ptr); } template constexpr add_pointer_t get_if(const variant<_Types...>* __ptr) noexcept { static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>, "T must occur exactly once in alternatives"); static_assert(!is_void_v<_Tp>, "_Tp must not be void"); constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>(); return std::get_if<__n>(__ptr); } namespace __detail::__variant { template constexpr _Ret __compare(_Ret __ret, const _Vp& __lhs, const _Vp& __rhs, _Op __op) { __variant::__raw_idx_visit( [&__ret, &__lhs, __op] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index.value) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __op(__this_mem, __rhs_mem); return; } } __ret = __op(__lhs.index() + 1, __rhs_index + 1); }, __rhs); return __ret; } } template constexpr bool operator== [[nodiscard]] (const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { namespace __variant = __detail::__variant; return __variant::__compare(true, __lhs, __rhs, [](auto&& __l, auto&& __r) -> bool { return __l == __r; }); } template constexpr bool operator!= [[nodiscard]] (const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { namespace __variant = __detail::__variant; return __variant::__compare(true, __lhs, __rhs, [](auto&& __l, auto&& __r) -> bool { return __l != __r; }); } template constexpr bool operator< [[nodiscard]] (const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { namespace __variant = __detail::__variant; return __variant::__compare(true, __lhs, __rhs, [](auto&& __l, auto&& __r) -> bool { return __l < __r; }); } template constexpr bool operator<= [[nodiscard]] (const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { namespace __variant = __detail::__variant; return __variant::__compare(true, __lhs, __rhs, [](auto&& __l, auto&& __r) -> bool { return __l <= __r; }); } template constexpr bool operator> [[nodiscard]] (const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { namespace __variant = __detail::__variant; return __variant::__compare(true, __lhs, __rhs, [](auto&& __l, auto&& __r) -> bool { return __l > __r; }); } template constexpr bool operator>= [[nodiscard]] (const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { namespace __variant = __detail::__variant; return __variant::__compare(true, __lhs, __rhs, [](auto&& __l, auto&& __r) -> bool { return __l >= __r; }); } # 1372 "/usr/include/c++/15/variant" 3 template constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...> visit(_Visitor&&, _Variants&&...); template inline enable_if_t<(is_move_constructible_v<_Types> && ...) && (is_swappable_v<_Types> && ...)> swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } template enable_if_t && ...) && (is_swappable_v<_Types> && ...))> swap(variant<_Types...>&, variant<_Types...>&) = delete; [[noreturn]] void __throw_bad_variant_access(unsigned); class bad_variant_access : public exception { public: bad_variant_access() noexcept { } const char* what() const noexcept override { return _M_reason; } private: bad_variant_access(const char* __reason) noexcept : _M_reason(__reason) { } const char* _M_reason = "bad variant access"; friend void __throw_bad_variant_access([[maybe_unused]] unsigned __n) { [[maybe_unused]] static constexpr const char* __reasons[] = { "std::get: wrong index for variant", "std::get: variant is valueless", "std::visit: variant is valueless", "std::visit: variant is valueless", }; (throw (bad_variant_access(__reasons[__n % 4u]))); } }; template class variant : private __detail::__variant::_Variant_base<_Types...>, private _Enable_copy_move< __detail::__variant::_Traits<_Types...>::_S_copy_ctor, __detail::__variant::_Traits<_Types...>::_S_copy_assign, __detail::__variant::_Traits<_Types...>::_S_move_ctor, __detail::__variant::_Traits<_Types...>::_S_move_assign, variant<_Types...>> { private: template friend decltype(auto) __variant_cast(_Tp&&); static_assert(sizeof...(_Types) > 0, "variant must have at least one alternative"); static_assert(((std::is_object_v<_Types> && !is_array_v<_Types>) && ...), "variant alternatives must be non-array object types"); using _Base = __detail::__variant::_Variant_base<_Types...>; template static constexpr bool __not_self = !is_same_v<__remove_cvref_t<_Tp>, variant>; template static constexpr bool __exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>; template static constexpr size_t __accepted_index = __detail::__variant::__accepted_index<_Tp, variant>; template> using __to_type = typename _Nth_type<_Np, _Types...>::type; template>> using __accepted_type = __to_type<__accepted_index<_Tp>>; template static constexpr size_t __index_of = std::__find_uniq_type_in_pack<_Tp, _Types...>(); using _Traits = __detail::__variant::_Traits<_Types...>; template static constexpr bool __not_in_place_tag = !__is_in_place_type_v<__remove_cvref_t<_Tp>> && !__is_in_place_index_v<__remove_cvref_t<_Tp>>; public: template, typename = enable_if_t>> constexpr variant() noexcept(is_nothrow_default_constructible_v<__to_type<0>>) { } variant(const variant& __rhs) = default; variant(variant&&) = default; variant& operator=(const variant&) = default; variant& operator=(variant&&) = default; ~variant() = default; template, typename = enable_if_t<__not_in_place_tag<_Tp>>, typename _Tj = __accepted_type<_Tp&&>, typename = enable_if_t<__exactly_once<_Tj> && is_constructible_v<_Tj, _Tp>>> constexpr variant(_Tp&& __t) noexcept(is_nothrow_constructible_v<_Tj, _Tp>) : variant(in_place_index<__accepted_index<_Tp>>, std::forward<_Tp>(__t)) { } template && is_constructible_v<_Tp, _Args...>>> constexpr explicit variant(in_place_type_t<_Tp>, _Args&&... __args) : variant(in_place_index<__index_of<_Tp>>, std::forward<_Args>(__args)...) { } template && is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>>> constexpr explicit variant(in_place_type_t<_Tp>, initializer_list<_Up> __il, _Args&&... __args) : variant(in_place_index<__index_of<_Tp>>, __il, std::forward<_Args>(__args)...) { } template, typename = enable_if_t>> constexpr explicit variant(in_place_index_t<_Np>, _Args&&... __args) : _Base(in_place_index<_Np>, std::forward<_Args>(__args)...) { } template, typename = enable_if_t&, _Args...>>> constexpr explicit variant(in_place_index_t<_Np>, initializer_list<_Up> __il, _Args&&... __args) : _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...) { } template enable_if_t<__exactly_once<__accepted_type<_Tp&&>> && is_constructible_v<__accepted_type<_Tp&&>, _Tp> && is_assignable_v<__accepted_type<_Tp&&>&, _Tp>, variant&> operator=(_Tp&& __rhs) noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp> && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>) { constexpr auto __index = __accepted_index<_Tp>; if (index() == __index) std::get<__index>(*this) = std::forward<_Tp>(__rhs); else { using _Tj = __accepted_type<_Tp&&>; if constexpr (is_nothrow_constructible_v<_Tj, _Tp> || !is_nothrow_move_constructible_v<_Tj>) this->emplace<__index>(std::forward<_Tp>(__rhs)); else this->emplace<__index>(_Tj(std::forward<_Tp>(__rhs))); } return *this; } template enable_if_t && __exactly_once<_Tp>, _Tp&> emplace(_Args&&... __args) { constexpr size_t __index = __index_of<_Tp>; return this->emplace<__index>(std::forward<_Args>(__args)...); } template enable_if_t&, _Args...> && __exactly_once<_Tp>, _Tp&> emplace(initializer_list<_Up> __il, _Args&&... __args) { constexpr size_t __index = __index_of<_Tp>; return this->emplace<__index>(__il, std::forward<_Args>(__args)...); } template enable_if_t, _Args...>, __to_type<_Np>&> emplace(_Args&&... __args) { namespace __variant = std::__detail::__variant; using type = typename _Nth_type<_Np, _Types...>::type; if constexpr (is_nothrow_constructible_v) { __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...); } else if constexpr (is_scalar_v) { const type __tmp(std::forward<_Args>(__args)...); __variant::__emplace<_Np>(*this, __tmp); } else if constexpr (__variant::_Never_valueless_alt() && _Traits::_S_move_assign) { variant __tmp(in_place_index<_Np>, std::forward<_Args>(__args)...); *this = std::move(__tmp); } else { __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...); } return std::get<_Np>(*this); } template enable_if_t, initializer_list<_Up>&, _Args...>, __to_type<_Np>&> emplace(initializer_list<_Up> __il, _Args&&... __args) { namespace __variant = std::__detail::__variant; using type = typename _Nth_type<_Np, _Types...>::type; if constexpr (is_nothrow_constructible_v&, _Args...>) { __variant::__emplace<_Np>(*this, __il, std::forward<_Args>(__args)...); } else if constexpr (__variant::_Never_valueless_alt() && _Traits::_S_move_assign) { variant __tmp(in_place_index<_Np>, __il, std::forward<_Args>(__args)...); *this = std::move(__tmp); } else { __variant::__emplace<_Np>(*this, __il, std::forward<_Args>(__args)...); } return std::get<_Np>(*this); } template enable_if_t emplace(_Args&&...) = delete; template enable_if_t> emplace(_Args&&...) = delete; constexpr bool valueless_by_exception() const noexcept { return !this->_M_valid(); } constexpr size_t index() const noexcept { using __index_type = typename _Base::__index_type; if constexpr (__detail::__variant::__never_valueless<_Types...>()) return this->_M_index; else if constexpr (sizeof...(_Types) <= __index_type(-1) / 2) return make_signed_t<__index_type>(this->_M_index); else return size_t(__index_type(this->_M_index + 1)) - 1; } void swap(variant& __rhs) noexcept((__is_nothrow_swappable<_Types>::value && ...) && is_nothrow_move_constructible_v) { static_assert((is_move_constructible_v<_Types> && ...)); if (__rhs.valueless_by_exception()) [[__unlikely__]] { if (!this->valueless_by_exception()) [[__likely__]] __rhs.swap(*this); return; } namespace __variant = __detail::__variant; __variant::__raw_idx_visit( [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) { if (this->index() == __j) { using std::swap; swap(std::get<__j>(*this), __rhs_mem); } else { auto __tmp(std::move(__rhs_mem)); if constexpr (_Traits::_S_trivial_move_assign) __rhs = std::move(*this); else __variant::__raw_idx_visit( [&__rhs](auto&& __this_mem, auto __this_index) mutable { constexpr size_t __k = __this_index; if constexpr (__k != variant_npos) __variant::__emplace<__k>(__rhs, std::move(__this_mem)); }, *this); __variant::__emplace<__j>(*this, std::move(__tmp)); } } }, __rhs); } # 1779 "/usr/include/c++/15/variant" 3 private: template friend constexpr decltype(auto) __detail::__variant::__get(_Vp&& __v) noexcept; }; template constexpr variant_alternative_t<_Np, variant<_Types...>>& get(variant<_Types...>& __v) { static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); if (__v.index() != _Np) __throw_bad_variant_access(__v.valueless_by_exception()); return __detail::__variant::__get<_Np>(__v); } template constexpr variant_alternative_t<_Np, variant<_Types...>>&& get(variant<_Types...>&& __v) { static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); if (__v.index() != _Np) __throw_bad_variant_access(__v.valueless_by_exception()); return __detail::__variant::__get<_Np>(std::move(__v)); } template constexpr const variant_alternative_t<_Np, variant<_Types...>>& get(const variant<_Types...>& __v) { static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); if (__v.index() != _Np) __throw_bad_variant_access(__v.valueless_by_exception()); return __detail::__variant::__get<_Np>(__v); } template constexpr const variant_alternative_t<_Np, variant<_Types...>>&& get(const variant<_Types...>&& __v) { static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); if (__v.index() != _Np) __throw_bad_variant_access(__v.valueless_by_exception()); return __detail::__variant::__get<_Np>(std::move(__v)); } template constexpr decltype(auto) __do_visit(_Visitor&& __visitor, _Variants&&... __variants) { if constexpr (sizeof...(_Variants) == 0) { if constexpr (is_void_v<_Result_type>) return (void) std::forward<_Visitor>(__visitor)(); else return std::forward<_Visitor>(__visitor)(); } else { constexpr size_t __max = 11; using _V0 = typename _Nth_type<0, _Variants...>::type; constexpr auto __n = variant_size_v>; if constexpr (sizeof...(_Variants) > 1 || __n > __max) { constexpr auto& __vtable = __detail::__variant::__gen_vtable< _Result_type, _Visitor&&, _Variants&&...>::_S_vtable; auto __func_ptr = __vtable._M_access(__variants.index()...); return (*__func_ptr)(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } else { _V0& __v0 = [](_V0& __v, ...) -> _V0& { return __v; }(__variants...); using __detail::__variant::_Multi_array; using __detail::__variant::__gen_vtable_impl; using _Ma = _Multi_array<_Result_type (*)(_Visitor&&, _V0&&)>; # 1889 "/usr/include/c++/15/variant" 3 switch (__v0.index()) { case 0: { if constexpr (0 < __n) { return __gen_vtable_impl<_Ma, index_sequence<0>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 1: { if constexpr (1 < __n) { return __gen_vtable_impl<_Ma, index_sequence<1>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 2: { if constexpr (2 < __n) { return __gen_vtable_impl<_Ma, index_sequence<2>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 3: { if constexpr (3 < __n) { return __gen_vtable_impl<_Ma, index_sequence<3>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 4: { if constexpr (4 < __n) { return __gen_vtable_impl<_Ma, index_sequence<4>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 5: { if constexpr (5 < __n) { return __gen_vtable_impl<_Ma, index_sequence<5>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 6: { if constexpr (6 < __n) { return __gen_vtable_impl<_Ma, index_sequence<6>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 7: { if constexpr (7 < __n) { return __gen_vtable_impl<_Ma, index_sequence<7>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 8: { if constexpr (8 < __n) { return __gen_vtable_impl<_Ma, index_sequence<8>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 9: { if constexpr (9 < __n) { return __gen_vtable_impl<_Ma, index_sequence<9>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case 10: { if constexpr (10 < __n) { return __gen_vtable_impl<_Ma, index_sequence<10>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); } case variant_npos: using __detail::__variant::__variant_idx_cookie; using __detail::__variant::__variant_cookie; if constexpr (is_same_v<_Result_type, __variant_idx_cookie> || is_same_v<_Result_type, __variant_cookie>) { using _Npos = index_sequence; return __gen_vtable_impl<_Ma, _Npos>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); default: __builtin_unreachable(); } } } } template constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...> visit(_Visitor&& __visitor, _Variants&&... __variants) { namespace __variant = std::__detail::__variant; if ((__variant::__as(__variants).valueless_by_exception() || ...)) __throw_bad_variant_access(2); using _Result_type = __detail::__variant::__visit_result_t<_Visitor, _Variants...>; using _Tag = __detail::__variant::__deduce_visit_result<_Result_type>; if constexpr (sizeof...(_Variants) == 1) { using _Vp = decltype(__variant::__as(std::declval<_Variants>()...)); constexpr bool __visit_rettypes_match = __detail::__variant:: __check_visitor_results<_Visitor, _Vp>( make_index_sequence>>()); if constexpr (!__visit_rettypes_match) { static_assert(__visit_rettypes_match, "std::visit requires the visitor to have the same " "return type for all alternatives of a variant"); return; } else return std::__do_visit<_Tag>( std::forward<_Visitor>(__visitor), static_cast<_Vp>(__variants)...); } else return std::__do_visit<_Tag>( std::forward<_Visitor>(__visitor), __variant::__as(std::forward<_Variants>(__variants))...); } # 1980 "/usr/include/c++/15/variant" 3 template struct __variant_hash { using result_type [[__deprecated__]] = size_t; using argument_type [[__deprecated__]] = variant<_Types...>; size_t operator()(const variant<_Types...>& __t) const noexcept((is_nothrow_invocable_v>, _Types> && ...)) { size_t __ret; __detail::__variant::__raw_visit( [&__t, &__ret](auto&& __t_mem) mutable { using _Type = __remove_cvref_t; if constexpr (!is_same_v<_Type, __detail::__variant::__variant_cookie>) __ret = std::hash{}(__t.index()) + std::hash<_Type>{}(__t_mem); else __ret = std::hash{}(__t.index()); }, __t); return __ret; } }; template struct hash> : __conditional_t<(__is_hash_enabled_for> && ...), __variant_hash<_Types...>, __hash_not_enabled>> , __detail::__variant::_Variant_hash_base, index_sequence_for<_Types...>> { }; template struct __is_fast_hash>> : bool_constant<(__is_fast_hash<_Types>::value && ...)> { }; } # 10 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" 2 # 56 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" # 59 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" namespace at::native { enum class CPUCapability { DEFAULT = 0, AVX2 = 1, AVX512 = 2, NUM_OPTIONS }; enum class ErrorType { MissingDeviceKernel, DeviceNotSupported }; using DispatchResult = std::variant; CPUCapability get_cpu_capability(); template struct DispatchStub; struct __attribute__((__visibility__("default"))) DispatchStubImpl { DispatchResult try_get_call_ptr( c10::DeviceType device_type , void *DEFAULT # 121 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" ); DispatchResult try_choose_cpu_impl( void *DEFAULT # 142 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" ); void* get_call_ptr( c10::DeviceType device_type , void *DEFAULT # 163 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" ); void* choose_cpu_impl( void *DEFAULT # 187 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" ); # 202 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" std::atomic cpu_dispatch_ptr{nullptr}; void* cuda_dispatch_ptr = nullptr; void* hip_dispatch_ptr = nullptr; void* mps_dispatch_ptr = nullptr; void* mtia_dispatch_ptr = nullptr; void* privateuse1_dispatch_ptr = nullptr; }; template struct DispatchStub { using FnPtr = rT (*) (Args...); DispatchStub() = default; DispatchStub(const DispatchStub&) = delete; DispatchStub& operator=(const DispatchStub&) = delete; private: FnPtr get_call_ptr(const c10::DeviceType device_type) { return reinterpret_cast( impl.get_call_ptr(device_type , reinterpret_cast(DEFAULT) # 242 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" ) ); } public: template rT operator()(c10::DeviceType device_type, ArgTypes&&... args) { FnPtr call_ptr = get_call_ptr(device_type); return (*call_ptr)(std::forward(args)...); } void set_cuda_dispatch_ptr(FnPtr fn_ptr) { impl.cuda_dispatch_ptr = reinterpret_cast(fn_ptr); } void set_hip_dispatch_ptr(FnPtr fn_ptr) { impl.hip_dispatch_ptr = reinterpret_cast(fn_ptr); } void set_mps_dispatch_ptr(FnPtr fn_ptr) { impl.mps_dispatch_ptr = reinterpret_cast(fn_ptr); } void set_mtia_dispatch_ptr(FnPtr fn_ptr) { impl.mtia_dispatch_ptr = reinterpret_cast(fn_ptr); } void set_privateuse1_dispatch_ptr(FnPtr fn_ptr) { impl.privateuse1_dispatch_ptr = reinterpret_cast(fn_ptr); } bool is_device_supported(const c10::DeviceType device_type) { auto result = impl.try_get_call_ptr(device_type , reinterpret_cast(DEFAULT) # 299 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" ); if (std::holds_alternative(result)){ return false; } return true; } static __attribute__((__visibility__("default"))) FnPtr DEFAULT; # 322 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" private: DispatchStubImpl impl; }; namespace { template struct RegisterCUDADispatch { RegisterCUDADispatch(DispatchStub &stub, typename DispatchStub::FnPtr value) { stub.set_cuda_dispatch_ptr(value); } }; template struct RegisterXPUDispatch { RegisterXPUDispatch(DispatchStub &stub, typename DispatchStub::FnPtr value){ stub.set_xpu_dispatch_ptr(value); } }; template struct RegisterMPSDispatch { RegisterMPSDispatch(DispatchStub &stub, typename DispatchStub::FnPtr value) { stub.set_mps_dispatch_ptr(value); } }; template struct RegisterHIPDispatch { RegisterHIPDispatch(DispatchStub &stub, typename DispatchStub::FnPtr value) { stub.set_cuda_dispatch_ptr(value); } }; template struct RegisterMTIADispatch { RegisterMTIADispatch(DispatchStub &stub, typename DispatchStub::FnPtr value) { stub.set_mtia_dispatch_ptr(value); } }; template struct RegisterPRIVATEUSE1Dispatch { RegisterPRIVATEUSE1Dispatch(DispatchStub &stub, typename DispatchStub::FnPtr value) { stub.set_privateuse1_dispatch_ptr(value); } }; } # 477 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/DispatchStub.h" } # 4 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" 1 # 16 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Deprecated.h" 1 # 20 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Backtrace.h" 1 # 1 "/usr/include/c++/15/memory" 1 3 # 68 "/usr/include/c++/15/memory" 3 # 1 "/usr/include/c++/15/bits/stl_tempbuf.h" 1 3 # 65 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 # 65 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 77 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 namespace __detail { template inline _Tp* __get_temporary_buffer(ptrdiff_t __len) noexcept { if (__builtin_expect(size_t(__len) > (size_t(-1) / sizeof(_Tp)), 0)) return 0; if (alignof(_Tp) > 16) return (_Tp*) __builtin_operator_new(__len * sizeof(_Tp), align_val_t(alignof(_Tp)), nothrow_t()); return (_Tp*) __builtin_operator_new(__len * sizeof(_Tp), nothrow_t()); } template inline void __return_temporary_buffer(_Tp* __p, size_t __len __attribute__((__unused__))) { if (alignof(_Tp) > 16) { __builtin_operator_delete((__p), (__len) * sizeof(_Tp), align_val_t(alignof(_Tp))); return; } __builtin_operator_delete((__p), (__len) * sizeof(_Tp)); } } # 140 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 template [[__deprecated__]] pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) noexcept { const ptrdiff_t __max = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); if (__len > __max) __len = __max; while (__len > 0) { if (_Tp* __tmp = __detail::__get_temporary_buffer<_Tp>(__len)) return pair<_Tp*, ptrdiff_t>(__tmp, __len); __len = __len == 1 ? 0 : ((__len + 1) / 2); } return pair<_Tp*, ptrdiff_t>(); } # 166 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 template [[__deprecated__]] inline void return_temporary_buffer(_Tp* __p) { if (alignof(_Tp) > 16) __builtin_operator_delete(__p, align_val_t(alignof(_Tp))); else __builtin_operator_delete(__p); } # 187 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 template class _Temporary_buffer { public: typedef _Tp value_type; typedef value_type* pointer; typedef pointer iterator; typedef ptrdiff_t size_type; protected: size_type _M_original_len; struct _Impl { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" explicit _Impl(ptrdiff_t __original_len) { pair __p( std::get_temporary_buffer(__original_len)); _M_len = __p.second; _M_buffer = __p.first; } #pragma GCC diagnostic pop ~_Impl() { std::__detail::__return_temporary_buffer(_M_buffer, _M_len); } size_type _M_len; pointer _M_buffer; } _M_impl; public: size_type size() const { return _M_impl._M_len; } size_type requested_size() const { return _M_original_len; } iterator begin() { return _M_impl._M_buffer; } iterator end() { return _M_impl._M_buffer + _M_impl._M_len; } _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); ~_Temporary_buffer() { std::_Destroy(_M_impl._M_buffer, _M_impl._M_buffer + _M_impl._M_len); } private: _Temporary_buffer(const _Temporary_buffer&); void operator=(const _Temporary_buffer&); }; template struct __uninitialized_construct_buf_dispatch { template static void __ucr(_Pointer __first, _Pointer __last, _ForwardIterator __seed) { if (__builtin_expect(__first == __last, 0)) return; _Pointer __cur = __first; try { std::_Construct(std::__addressof(*__first), std::move(*__seed)); _Pointer __prev = __cur; ++__cur; for(; __cur != __last; ++__cur, ++__prev) std::_Construct(std::__addressof(*__cur), std::move(*__prev)); *__seed = std::move(*__prev); } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_construct_buf_dispatch { template static void __ucr(_Pointer, _Pointer, _ForwardIterator) { } }; # 311 "/usr/include/c++/15/bits/stl_tempbuf.h" 3 template inline void __uninitialized_construct_buf(_Tp* __first, _Tp* __last, _ForwardIterator __seed) { std::__uninitialized_construct_buf_dispatch< __has_trivial_constructor(_Tp)>:: __ucr(__first, __last, __seed); } template _Temporary_buffer<_ForwardIterator, _Tp>:: _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) : _M_original_len(__original_len), _M_impl(__original_len) { std::__uninitialized_construct_buf(begin(), end(), __seed); } } # 69 "/usr/include/c++/15/memory" 2 3 # 1 "/usr/include/c++/15/bits/stl_raw_storage_iter.h" 1 3 # 59 "/usr/include/c++/15/bits/stl_raw_storage_iter.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 64 "/usr/include/c++/15/bits/stl_raw_storage_iter.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template class [[__deprecated__]] raw_storage_iterator : public iterator { protected: _OutputIterator _M_iter; public: explicit raw_storage_iterator(_OutputIterator __x) : _M_iter(__x) {} raw_storage_iterator& operator*() { return *this; } raw_storage_iterator& operator=(const _Tp& __element) { std::_Construct(std::__addressof(*_M_iter), __element); return *this; } raw_storage_iterator& operator=(_Tp&& __element) { std::_Construct(std::__addressof(*_M_iter), std::move(__element)); return *this; } raw_storage_iterator& operator++() { ++_M_iter; return *this; } raw_storage_iterator operator++(int) { raw_storage_iterator __tmp = *this; ++_M_iter; return __tmp; } _OutputIterator base() const { return _M_iter; } }; #pragma GCC diagnostic pop } # 73 "/usr/include/c++/15/memory" 2 3 # 1 "/usr/include/c++/15/bits/align.h" 1 3 # 35 "/usr/include/c++/15/bits/align.h" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 36 "/usr/include/c++/15/bits/align.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 59 "/usr/include/c++/15/bits/align.h" 3 inline void* align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept { if (__space < __size) return nullptr; const auto __intptr = reinterpret_cast(__ptr); const auto __aligned = (__intptr - 1u + __align) & -__align; const auto __diff = __aligned - __intptr; if (__diff > (__space - __size)) return nullptr; else { __space -= __diff; return __ptr = reinterpret_cast(__aligned); } } # 105 "/usr/include/c++/15/bits/align.h" 3 } # 77 "/usr/include/c++/15/memory" 2 3 # 1 "/usr/include/c++/15/bits/unique_ptr.h" 1 3 # 46 "/usr/include/c++/15/bits/unique_ptr.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 56 "/usr/include/c++/15/bits/unique_ptr.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template class auto_ptr; #pragma GCC diagnostic pop template struct default_delete { constexpr default_delete() noexcept = default; template>> default_delete(const default_delete<_Up>&) noexcept { } void operator()(_Tp* __ptr) const { static_assert(!is_void<_Tp>::value, "can't delete pointer to incomplete type"); static_assert(sizeof(_Tp)>0, "can't delete pointer to incomplete type"); delete __ptr; } }; # 104 "/usr/include/c++/15/bits/unique_ptr.h" 3 template struct default_delete<_Tp[]> { public: constexpr default_delete() noexcept = default; # 120 "/usr/include/c++/15/bits/unique_ptr.h" 3 template>> default_delete(const default_delete<_Up[]>&) noexcept { } template typename enable_if::value>::type operator()(_Up* __ptr) const { static_assert(sizeof(_Tp)>0, "can't delete pointer to incomplete type"); delete [] __ptr; } }; template class __uniq_ptr_impl { template struct _Ptr { using type = _Up*; }; template struct _Ptr<_Up, _Ep, __void_t::type::pointer>> { using type = typename remove_reference<_Ep>::type::pointer; }; public: using _DeleterConstraint = enable_if< __and_<__not_>, is_default_constructible<_Dp>>::value>; using pointer = typename _Ptr<_Tp, _Dp>::type; static_assert( !is_rvalue_reference<_Dp>::value, "unique_ptr's deleter type must be a function object type" " or an lvalue reference type" ); __uniq_ptr_impl() = default; __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } template __uniq_ptr_impl(pointer __p, _Del&& __d) : _M_t(__p, std::forward<_Del>(__d)) { } __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept : _M_t(std::move(__u._M_t)) { __u._M_ptr() = nullptr; } __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept { reset(__u.release()); _M_deleter() = std::forward<_Dp>(__u._M_deleter()); return *this; } pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } void reset(pointer __p) noexcept { const pointer __old_p = _M_ptr(); _M_ptr() = __p; if (__old_p) _M_deleter()(__old_p); } pointer release() noexcept { pointer __p = _M_ptr(); _M_ptr() = nullptr; return __p; } void swap(__uniq_ptr_impl& __rhs) noexcept { using std::swap; swap(this->_M_ptr(), __rhs._M_ptr()); swap(this->_M_deleter(), __rhs._M_deleter()); } private: tuple _M_t; }; template ::value, bool = is_move_assignable<_Dp>::value> struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = default; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; }; template struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = default; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; }; template struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = delete; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; }; template struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = delete; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; }; template > class unique_ptr { template using _DeleterConstraint = typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; __uniq_ptr_data<_Tp, _Dp> _M_t; public: using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; using element_type = _Tp; using deleter_type = _Dp; private: template using __safe_conversion_up = __and_< is_convertible::pointer, pointer>, __not_> >; public: template> constexpr unique_ptr() noexcept : _M_t() { } template> explicit unique_ptr(pointer __p) noexcept : _M_t(__p) { } # 321 "/usr/include/c++/15/bits/unique_ptr.h" 3 template>> unique_ptr(pointer __p, const deleter_type& __d) noexcept : _M_t(__p, __d) { } # 334 "/usr/include/c++/15/bits/unique_ptr.h" 3 template>> unique_ptr(pointer __p, __enable_if_t::value, _Del&&> __d) noexcept : _M_t(__p, std::move(__d)) { } template::type> unique_ptr(pointer, __enable_if_t::value, _DelUnref&&>) = delete; template> constexpr unique_ptr(nullptr_t) noexcept : _M_t() { } unique_ptr(unique_ptr&&) = default; template, __conditional_t::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>>> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template, is_same<_Dp, default_delete<_Tp>>>> unique_ptr(auto_ptr<_Up>&& __u) noexcept; #pragma GCC diagnostic pop ~unique_ptr() noexcept { static_assert(__is_invocable::value, "unique_ptr's deleter must be invocable with a pointer"); auto& __ptr = _M_t._M_ptr(); if (__ptr != nullptr) get_deleter()(std::move(__ptr)); __ptr = pointer(); } unique_ptr& operator=(unique_ptr&&) = default; # 417 "/usr/include/c++/15/bits/unique_ptr.h" 3 template typename enable_if< __and_< __safe_conversion_up<_Up, _Ep>, is_assignable >::value, unique_ptr&>::type operator=(unique_ptr<_Up, _Ep>&& __u) noexcept { reset(__u.release()); get_deleter() = std::forward<_Ep>(__u.get_deleter()); return *this; } unique_ptr& operator=(nullptr_t) noexcept { reset(); return *this; } typename add_lvalue_reference::type operator*() const noexcept(noexcept(*std::declval())) { using _ResT = typename add_lvalue_reference::type; using _DerefT = decltype(*get()); static_assert(!__reference_converts_from_temporary(_ResT, _DerefT), "operator* must not return a dangling reference"); do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) std::__glibcxx_assert_fail(); } while (false); return *get(); } pointer operator->() const noexcept { ; return get(); } pointer get() const noexcept { return _M_t._M_ptr(); } deleter_type& get_deleter() noexcept { return _M_t._M_deleter(); } const deleter_type& get_deleter() const noexcept { return _M_t._M_deleter(); } explicit operator bool() const noexcept { return get() == pointer() ? false : true; } pointer release() noexcept { return _M_t.release(); } void reset(pointer __p = pointer()) noexcept { static_assert(__is_invocable::value, "unique_ptr's deleter must be invocable with a pointer"); _M_t.reset(std::move(__p)); } void swap(unique_ptr& __u) noexcept { static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); _M_t.swap(__u._M_t); } unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; private: }; # 544 "/usr/include/c++/15/bits/unique_ptr.h" 3 template class unique_ptr<_Tp[], _Dp> { template using _DeleterConstraint = typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; __uniq_ptr_data<_Tp, _Dp> _M_t; template using __is_derived_Tp = __and_< is_base_of<_Tp, _Up>, __not_, __remove_cv_t<_Up>>> >; public: using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; using element_type = _Tp; using deleter_type = _Dp; template, typename _UP_pointer = typename _UPtr::pointer, typename _UP_element_type = typename _UPtr::element_type> using __safe_conversion_up = __and_< is_array<_Up>, is_same, is_same<_UP_pointer, _UP_element_type*>, is_convertible<_UP_element_type(*)[], element_type(*)[]> >; template using __safe_conversion_raw = __and_< __or_<__or_, is_same<_Up, nullptr_t>>, __and_, is_same, is_convertible< typename remove_pointer<_Up>::type(*)[], element_type(*)[]> > > >; template> constexpr unique_ptr() noexcept : _M_t() { } # 606 "/usr/include/c++/15/bits/unique_ptr.h" 3 template, typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type> explicit unique_ptr(_Up __p) noexcept : _M_t(__p) { } # 625 "/usr/include/c++/15/bits/unique_ptr.h" 3 template, is_copy_constructible<_Del>>> unique_ptr(_Up __p, const deleter_type& __d) noexcept : _M_t(__p, __d) { } # 640 "/usr/include/c++/15/bits/unique_ptr.h" 3 template, is_move_constructible<_Del>>> unique_ptr(_Up __p, __enable_if_t::value, _Del&&> __d) noexcept : _M_t(std::move(__p), std::move(__d)) { } template::type, typename = _Require<__safe_conversion_raw<_Up>>> unique_ptr(_Up, __enable_if_t::value, _DelUnref&&>) = delete; unique_ptr(unique_ptr&&) = default; template> constexpr unique_ptr(nullptr_t) noexcept : _M_t() { } template, __conditional_t::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>>> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } ~unique_ptr() { auto& __ptr = _M_t._M_ptr(); if (__ptr != nullptr) get_deleter()(__ptr); __ptr = pointer(); } unique_ptr& operator=(unique_ptr&&) = default; # 704 "/usr/include/c++/15/bits/unique_ptr.h" 3 template typename enable_if<__and_<__safe_conversion_up<_Up, _Ep>, is_assignable >::value, unique_ptr&>::type operator=(unique_ptr<_Up, _Ep>&& __u) noexcept { reset(__u.release()); get_deleter() = std::forward<_Ep>(__u.get_deleter()); return *this; } unique_ptr& operator=(nullptr_t) noexcept { reset(); return *this; } typename std::add_lvalue_reference::type operator[](size_t __i) const { do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) std::__glibcxx_assert_fail(); } while (false); return get()[__i]; } pointer get() const noexcept { return _M_t._M_ptr(); } deleter_type& get_deleter() noexcept { return _M_t._M_deleter(); } const deleter_type& get_deleter() const noexcept { return _M_t._M_deleter(); } explicit operator bool() const noexcept { return get() == pointer() ? false : true; } pointer release() noexcept { return _M_t.release(); } template , __and_, is_pointer<_Up>, is_convertible< typename remove_pointer<_Up>::type(*)[], element_type(*)[] > > > >> void reset(_Up __p) noexcept { _M_t.reset(std::move(__p)); } void reset(nullptr_t = nullptr) noexcept { reset(pointer()); } void swap(unique_ptr& __u) noexcept { static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); _M_t.swap(__u._M_t); } unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; private: }; template inline typename enable_if<__is_swappable<_Dp>::value>::type swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) noexcept { __x.swap(__y); } template typename enable_if::value>::type swap(unique_ptr<_Tp, _Dp>&, unique_ptr<_Tp, _Dp>&) = delete; template [[__nodiscard__]] inline bool operator==(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return __x.get() == __y.get(); } template [[__nodiscard__]] inline bool operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept { return !__x; } template [[__nodiscard__]] inline bool operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept { return !__x; } template [[__nodiscard__]] inline bool operator!=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return __x.get() != __y.get(); } template [[__nodiscard__]] inline bool operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept { return (bool)__x; } template [[__nodiscard__]] inline bool operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept { return (bool)__x; } template [[__nodiscard__]] inline bool operator<(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { typedef typename std::common_type::pointer, typename unique_ptr<_Up, _Ep>::pointer>::type _CT; return std::less<_CT>()(__x.get(), __y.get()); } template [[__nodiscard__]] inline bool operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return std::less::pointer>()(__x.get(), nullptr); } template [[__nodiscard__]] inline bool operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return std::less::pointer>()(nullptr, __x.get()); } template [[__nodiscard__]] inline bool operator<=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline bool operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return !(nullptr < __x); } template [[__nodiscard__]] inline bool operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return !(__x < nullptr); } template [[__nodiscard__]] inline bool operator>(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return (__y < __x); } template [[__nodiscard__]] inline bool operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return std::less::pointer>()(nullptr, __x.get()); } template [[__nodiscard__]] inline bool operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return std::less::pointer>()(__x.get(), nullptr); } template [[__nodiscard__]] inline bool operator>=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return !(__x < __y); } template [[__nodiscard__]] inline bool operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return !(__x < nullptr); } template [[__nodiscard__]] inline bool operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return !(nullptr < __x); } # 1022 "/usr/include/c++/15/bits/unique_ptr.h" 3 template struct __uniq_ptr_hash : public __hash_base , private __hash_empty_base<_Ptr> { size_t operator()(const _Up& __u) const noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) { return hash<_Ptr>()(__u.get()); } }; template using __uniq_ptr_hash_base = __conditional_t<__is_hash_enabled_for, __uniq_ptr_hash<_Up>, __hash_not_enabled>; template struct hash> : public __uniq_ptr_hash_base> { }; namespace __detail { template struct _MakeUniq { typedef unique_ptr<_Tp> __single_object; }; template struct _MakeUniq<_Tp[]> { typedef unique_ptr<_Tp[]> __array; }; template struct _MakeUniq<_Tp[_Bound]> { struct __invalid_type { }; }; template using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object; template using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array; template using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type; } # 1080 "/usr/include/c++/15/bits/unique_ptr.h" 3 template inline __detail::__unique_ptr_t<_Tp> make_unique(_Args&&... __args) { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } # 1095 "/usr/include/c++/15/bits/unique_ptr.h" 3 template inline __detail::__unique_ptr_array_t<_Tp> make_unique(size_t __num) { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } template __detail::__invalid_make_unique_t<_Tp> make_unique(_Args&&...) = delete; # 1166 "/usr/include/c++/15/bits/unique_ptr.h" 3 template constexpr bool __is_unique_ptr = false; template constexpr bool __is_unique_ptr> = true; namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::true_type { }; } } # 81 "/usr/include/c++/15/memory" 2 3 # 1 "/usr/include/c++/15/bits/shared_ptr.h" 1 3 # 53 "/usr/include/c++/15/bits/shared_ptr.h" 3 # 1 "/usr/include/c++/15/bits/shared_ptr_base.h" 1 3 # 53 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 # 1 "/usr/include/c++/15/bits/allocated_ptr.h" 1 3 # 40 "/usr/include/c++/15/bits/allocated_ptr.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct __allocated_ptr { using pointer = typename allocator_traits<_Alloc>::pointer; using value_type = typename allocator_traits<_Alloc>::value_type; __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr) { } template>> __allocated_ptr(_Alloc& __a, _Ptr __ptr) : _M_alloc(std::__addressof(__a)), _M_ptr(pointer_traits::pointer_to(*__ptr)) { } __allocated_ptr(__allocated_ptr&& __gd) noexcept : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr) { __gd._M_ptr = nullptr; } ~__allocated_ptr() { if (_M_ptr != nullptr) std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); } __allocated_ptr& operator=(std::nullptr_t) noexcept { _M_ptr = nullptr; return *this; } explicit operator bool() const noexcept { return (bool)_M_ptr; } value_type* get() const { return std::__to_address(_M_ptr); } pointer release() { return std::__exchange(_M_ptr, nullptr); } private: _Alloc* _M_alloc; pointer _M_ptr; }; template inline __allocated_ptr<_Alloc> __allocate_guarded(_Alloc& __a) { return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; } template struct __allocated_obj : __allocated_ptr<_Alloc> { using value_type = typename __allocated_ptr<_Alloc>::value_type; __allocated_obj(__allocated_obj<_Alloc>&&) = default; __allocated_obj(__allocated_ptr<_Alloc>&& __ptr) : __allocated_ptr<_Alloc>(std::move(__ptr)) { ::new ((void*)this->get()) value_type; } ~__allocated_obj() { if (static_cast(*this)) this->get()->~value_type(); } using __allocated_ptr<_Alloc>::operator=; value_type& operator*() const { return *this->get(); } value_type* operator->() const { return this->get(); } }; template inline __allocated_obj<_Alloc> __allocate_guarded_obj(_Alloc& __a) { return { std::__allocate_guarded(__a) }; } } # 54 "/usr/include/c++/15/bits/shared_ptr_base.h" 2 3 # 62 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 # 1 "/usr/include/c++/15/ext/concurrence.h" 1 3 # 42 "/usr/include/c++/15/ext/concurrence.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; inline const _Lock_policy __default_lock_policy = _S_mutex; class __concurrence_lock_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_lock_error"; } }; class __concurrence_unlock_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_unlock_error"; } }; class __concurrence_broadcast_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_broadcast_error"; } }; class __concurrence_wait_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_wait_error"; } }; inline void __throw_concurrence_lock_error() { (throw (__concurrence_lock_error())); } inline void __throw_concurrence_unlock_error() { (throw (__concurrence_unlock_error())); } inline void __throw_concurrence_broadcast_error() { (throw (__concurrence_broadcast_error())); } inline void __throw_concurrence_wait_error() { (throw (__concurrence_wait_error())); } class __mutex { private: __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, { 0, 0 } } }; __mutex(const __mutex&); __mutex& operator=(const __mutex&); public: __mutex() { } # 149 "/usr/include/c++/15/ext/concurrence.h" 3 void lock() { if (__gthread_active_p()) { if (__gthread_mutex_lock(&_M_mutex) != 0) __throw_concurrence_lock_error(); } } void unlock() { if (__gthread_active_p()) { if (__gthread_mutex_unlock(&_M_mutex) != 0) __throw_concurrence_unlock_error(); } } __gthread_mutex_t* gthread_mutex(void) { return &_M_mutex; } }; class __recursive_mutex { private: __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, { 0, 0 } } }; __recursive_mutex(const __recursive_mutex&); __recursive_mutex& operator=(const __recursive_mutex&); public: __recursive_mutex() { } # 204 "/usr/include/c++/15/ext/concurrence.h" 3 void lock() { if (__gthread_active_p()) { if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) __throw_concurrence_lock_error(); } } void unlock() { if (__gthread_active_p()) { if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) __throw_concurrence_unlock_error(); } } __gthread_recursive_mutex_t* gthread_recursive_mutex(void) { return &_M_mutex; } }; class __scoped_lock { public: typedef __mutex __mutex_type; private: __mutex_type& _M_device; __scoped_lock(const __scoped_lock&); __scoped_lock& operator=(const __scoped_lock&); public: explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) { _M_device.lock(); } ~__scoped_lock() throw() { _M_device.unlock(); } }; class __cond { private: __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, 0, 0, {0, 0}, 0, 0 } }; __cond(const __cond&); __cond& operator=(const __cond&); public: __cond() { } # 282 "/usr/include/c++/15/ext/concurrence.h" 3 void broadcast() { if (__gthread_active_p()) { if (__gthread_cond_broadcast(&_M_cond) != 0) __throw_concurrence_broadcast_error(); } } void wait(__mutex *mutex) { { if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) __throw_concurrence_wait_error(); } } void wait_recursive(__recursive_mutex *mutex) { { if (__gthread_cond_wait_recursive(&_M_cond, mutex->gthread_recursive_mutex()) != 0) __throw_concurrence_wait_error(); } } }; } #pragma GCC diagnostic pop # 63 "/usr/include/c++/15/bits/shared_ptr_base.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 74 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template class auto_ptr; #pragma GCC diagnostic pop class bad_weak_ptr : public std::exception { public: virtual char const* what() const noexcept; virtual ~bad_weak_ptr() noexcept; }; inline void __throw_bad_weak_ptr() { (throw (bad_weak_ptr())); } using __gnu_cxx::_Lock_policy; using __gnu_cxx::__default_lock_policy; using __gnu_cxx::_S_single; using __gnu_cxx::_S_mutex; using __gnu_cxx::_S_atomic; template<_Lock_policy _Lp> class _Mutex_base { protected: enum { _S_need_barriers = 0 }; }; template<> class _Mutex_base<_S_mutex> : public __gnu_cxx::__mutex { protected: enum { _S_need_barriers = 1 }; }; template<_Lock_policy _Lp = __default_lock_policy> class _Sp_counted_base : public _Mutex_base<_Lp> { public: _Sp_counted_base() noexcept : _M_use_count(1), _M_weak_count(1) { } virtual ~_Sp_counted_base() noexcept { } virtual void _M_dispose() noexcept = 0; virtual void _M_destroy() noexcept { delete this; } virtual void* _M_get_deleter(const std::type_info&) noexcept = 0; void _M_add_ref_copy() { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } void _M_add_ref_lock() { if (!_M_add_ref_lock_nothrow()) __throw_bad_weak_ptr(); } bool _M_add_ref_lock_nothrow() noexcept; void _M_release() noexcept; void _M_release_last_use() noexcept { ; _M_dispose(); if (_Mutex_base<_Lp>::_S_need_barriers) { __atomic_thread_fence (4); } ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) { ; _M_destroy(); } } __attribute__((__noinline__)) void _M_release_last_use_cold() noexcept { _M_release_last_use(); } void _M_weak_add_ref() noexcept { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } void _M_weak_release() noexcept { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) { ; if (_Mutex_base<_Lp>::_S_need_barriers) { __atomic_thread_fence (4); } _M_destroy(); } } long _M_get_use_count() const noexcept { return __atomic_load_n(&_M_use_count, 0); } private: _Sp_counted_base(_Sp_counted_base const&) = delete; _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; _Atomic_word _M_use_count; _Atomic_word _M_weak_count; }; template<> inline bool _Sp_counted_base<_S_single>:: _M_add_ref_lock_nothrow() noexcept { if (_M_use_count == 0) return false; ++_M_use_count; return true; } template<> inline bool _Sp_counted_base<_S_mutex>:: _M_add_ref_lock_nothrow() noexcept { __gnu_cxx::__scoped_lock sentry(*this); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) { _M_use_count = 0; return false; } return true; } template<> inline bool _Sp_counted_base<_S_atomic>:: _M_add_ref_lock_nothrow() noexcept { _Atomic_word __count = _M_get_use_count(); do { if (__count == 0) return false; } while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, true, 4, 0)); return true; } template<> inline void _Sp_counted_base<_S_single>::_M_add_ref_copy() { ++_M_use_count; } template<> inline void _Sp_counted_base<_S_single>::_M_release() noexcept { if (--_M_use_count == 0) { _M_dispose(); if (--_M_weak_count == 0) _M_destroy(); } } template<> inline void _Sp_counted_base<_S_mutex>::_M_release() noexcept { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) { _M_release_last_use(); } } template<> inline void _Sp_counted_base<_S_atomic>::_M_release() noexcept { ; constexpr bool __lock_free = __atomic_always_lock_free(sizeof(long long), 0) && __atomic_always_lock_free(sizeof(_Atomic_word), 0); constexpr bool __double_word = sizeof(long long) == 2 * sizeof(_Atomic_word); constexpr bool __aligned = __alignof(long long) <= alignof(void*); if constexpr (__lock_free && __double_word && __aligned) { constexpr int __wordbits = 8 * sizeof(_Atomic_word); constexpr int __shiftbits = __double_word ? __wordbits : 0; constexpr long long __unique_ref = 1LL + (1LL << __shiftbits); auto __both_counts = reinterpret_cast(&_M_use_count); ; if (__atomic_load_n(__both_counts, 2) == __unique_ref) { _M_weak_count = _M_use_count = 0; ; ; _M_dispose(); _M_destroy(); return; } if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) [[__unlikely__]] { _M_release_last_use_cold(); return; } } else if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) { _M_release_last_use(); } } template<> inline void _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept { ++_M_weak_count; } template<> inline void _Sp_counted_base<_S_single>::_M_weak_release() noexcept { if (--_M_weak_count == 0) _M_destroy(); } template<> inline long _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept { return _M_use_count; } template class __shared_ptr; template class __weak_ptr; template class __enable_shared_from_this; template class shared_ptr; template class weak_ptr; template struct owner_less; template class enable_shared_from_this; template<_Lock_policy _Lp = __default_lock_policy> class __weak_count; template<_Lock_policy _Lp = __default_lock_policy> class __shared_count; template class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> { public: explicit _Sp_counted_ptr(_Ptr __p) noexcept : _M_ptr(__p) { } virtual void _M_dispose() noexcept { delete _M_ptr; } virtual void _M_destroy() noexcept { delete this; } virtual void* _M_get_deleter(const std::type_info&) noexcept { return nullptr; } _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; private: _Ptr _M_ptr; }; template<> inline void _Sp_counted_ptr::_M_dispose() noexcept { } template<> inline void _Sp_counted_ptr::_M_dispose() noexcept { } template<> inline void _Sp_counted_ptr::_M_dispose() noexcept { } template struct _Sp_ebo_helper; template struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp { explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } static _Tp& _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } }; template struct _Sp_ebo_helper<_Nm, _Tp, false> { explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } static _Tp& _S_get(_Sp_ebo_helper& __eboh) { return __eboh._M_tp; } private: _Tp _M_tp; }; template class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> { class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> { typedef _Sp_ebo_helper<0, _Deleter> _Del_base; typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; public: _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p) { } _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } _Ptr _M_ptr; }; public: using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept : _M_impl(__p, std::move(__d), _Alloc()) { } _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept : _M_impl(__p, std::move(__d), __a) { } ~_Sp_counted_deleter() noexcept { } virtual void _M_dispose() noexcept { _M_impl._M_del()(_M_impl._M_ptr); } virtual void _M_destroy() noexcept { __allocator_type __a(_M_impl._M_alloc()); __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; this->~_Sp_counted_deleter(); } virtual void* _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept { return __ti == typeid(_Deleter) ? std::__addressof(_M_impl._M_del()) : nullptr; } private: _Impl _M_impl; }; struct _Sp_make_shared_tag { private: template friend class _Sp_counted_ptr_inplace; static const type_info& _S_ti() noexcept __attribute__ ((__visibility__ ("default"))) { alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; return reinterpret_cast(__tag); } static bool _S_eq(const type_info&) noexcept; }; template struct _Sp_alloc_shared_tag { const _Alloc& _M_a; }; template class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> { class _Impl : _Sp_ebo_helper<0, _Alloc> { typedef _Sp_ebo_helper<0, _Alloc> _A_base; public: explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } __gnu_cxx::__aligned_buffer<__remove_cv_t<_Tp>> _M_storage; }; public: using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; template _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) : _M_impl(__a) { allocator_traits<_Alloc>::construct(__a, _M_ptr(), std::forward<_Args>(__args)...); } ~_Sp_counted_ptr_inplace() noexcept { } virtual void _M_dispose() noexcept { allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); } virtual void _M_destroy() noexcept { __allocator_type __a(_M_impl._M_alloc()); __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; this->~_Sp_counted_ptr_inplace(); } private: friend class __shared_count<_Lp>; virtual void* _M_get_deleter(const std::type_info& __ti) noexcept override { if (&__ti == &_Sp_make_shared_tag::_S_ti() || __ti == typeid(_Sp_make_shared_tag) ) return _M_ptr(); return nullptr; } __remove_cv_t<_Tp>* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } _Impl _M_impl; }; # 883 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 struct __sp_array_delete { template void operator()(_Yp* __p) const { delete[] __p; } }; template<_Lock_policy _Lp> class __shared_count { template struct __not_alloc_shared_tag { using type = void; }; template struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; public: constexpr __shared_count() noexcept : _M_pi(0) { } template explicit __shared_count(_Ptr __p) : _M_pi(0) { try { _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); } catch(...) { delete __p; throw; } } template __shared_count(_Ptr __p, false_type) : __shared_count(__p) { } template __shared_count(_Ptr __p, true_type) : __shared_count(__p, __sp_array_delete{}, allocator()) { } template::type> __shared_count(_Ptr __p, _Deleter __d) : __shared_count(__p, std::move(__d), allocator()) { } template::type> __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) { typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; try { typename _Sp_cd_type::__allocator_type __a2(__a); auto __guard = std::__allocate_guarded(__a2); _Sp_cd_type* __mem = __guard.get(); ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); _M_pi = __mem; __guard = nullptr; } catch(...) { __d(__p); throw; } } template __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, _Args&&... __args) { using _Tp2 = __remove_cv_t<_Tp>; using _Sp_cp_type = _Sp_counted_ptr_inplace<_Tp2, _Alloc, _Lp>; typename _Sp_cp_type::__allocator_type __a2(__a._M_a); auto __guard = std::__allocate_guarded(__a2); _Sp_cp_type* __mem = __guard.get(); auto __pi = ::new (__mem) _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); __guard = nullptr; _M_pi = __pi; __p = __pi->_M_ptr(); } # 1022 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template explicit __shared_count(std::auto_ptr<_Tp>&& __r); #pragma GCC diagnostic pop template explicit __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) { if (__r.get() == nullptr) return; using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; using _Del2 = __conditional_t::value, reference_wrapper::type>, _Del>; using _Sp_cd_type = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; using _Alloc = allocator<_Sp_cd_type>; using _Alloc_traits = allocator_traits<_Alloc>; _Alloc __a; _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); _Alloc_traits::construct(__a, __mem, __r.release(), std::forward<_Del>(__r.get_deleter())); _M_pi = __mem; } explicit __shared_count(const __weak_count<_Lp>& __r); explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept; ~__shared_count() noexcept { if (_M_pi != nullptr) _M_pi->_M_release(); } __shared_count(const __shared_count& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != nullptr) _M_pi->_M_add_ref_copy(); } __shared_count& operator=(const __shared_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != _M_pi) { if (__tmp != nullptr) __tmp->_M_add_ref_copy(); if (_M_pi != nullptr) _M_pi->_M_release(); _M_pi = __tmp; } return *this; } void _M_swap(__shared_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; __r._M_pi = _M_pi; _M_pi = __tmp; } long _M_get_use_count() const noexcept { return _M_pi ? _M_pi->_M_get_use_count() : 0; } bool _M_unique() const noexcept { return this->_M_get_use_count() == 1; } void* _M_get_deleter(const std::type_info& __ti) const noexcept { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } bool _M_less(const __shared_count& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } bool _M_less(const __weak_count<_Lp>& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } friend inline bool operator==(const __shared_count& __a, const __shared_count& __b) noexcept { return __a._M_pi == __b._M_pi; } private: friend class __weak_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; }; template<_Lock_policy _Lp> class __weak_count { public: constexpr __weak_count() noexcept : _M_pi(nullptr) { } __weak_count(const __shared_count<_Lp>& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != nullptr) _M_pi->_M_weak_add_ref(); } __weak_count(const __weak_count& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != nullptr) _M_pi->_M_weak_add_ref(); } __weak_count(__weak_count&& __r) noexcept : _M_pi(__r._M_pi) { __r._M_pi = nullptr; } ~__weak_count() noexcept { if (_M_pi != nullptr) _M_pi->_M_weak_release(); } __weak_count& operator=(const __shared_count<_Lp>& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != nullptr) __tmp->_M_weak_add_ref(); if (_M_pi != nullptr) _M_pi->_M_weak_release(); _M_pi = __tmp; return *this; } __weak_count& operator=(const __weak_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != nullptr) __tmp->_M_weak_add_ref(); if (_M_pi != nullptr) _M_pi->_M_weak_release(); _M_pi = __tmp; return *this; } __weak_count& operator=(__weak_count&& __r) noexcept { if (_M_pi != nullptr) _M_pi->_M_weak_release(); _M_pi = __r._M_pi; __r._M_pi = nullptr; return *this; } void _M_swap(__weak_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; __r._M_pi = _M_pi; _M_pi = __tmp; } long _M_get_use_count() const noexcept { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } bool _M_less(const __weak_count& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } bool _M_less(const __shared_count<_Lp>& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } friend inline bool operator==(const __weak_count& __a, const __weak_count& __b) noexcept { return __a._M_pi == __b._M_pi; } private: friend class __shared_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; }; template<_Lock_policy _Lp> inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) : _M_pi(__r._M_pi) { if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow()) __throw_bad_weak_ptr(); } template<_Lock_policy _Lp> inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept : _M_pi(__r._M_pi) { if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow()) _M_pi = nullptr; } template struct __sp_compatible_with : false_type { }; template struct __sp_compatible_with<_Yp*, _Tp*> : is_convertible<_Yp*, _Tp*>::type { }; template struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> : true_type { }; template struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> : true_type { }; template struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> : true_type { }; template struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> : true_type { }; template struct __sp_is_constructible_arrN : false_type { }; template struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type { }; template struct __sp_is_constructible_arr : false_type { }; template struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> : is_convertible<_Yp(*)[], _Up(*)[]>::type { }; template struct __sp_is_constructible; template struct __sp_is_constructible<_Up[_Nm], _Yp> : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type { }; template struct __sp_is_constructible<_Up[], _Yp> : __sp_is_constructible_arr<_Up, _Yp>::type { }; template struct __sp_is_constructible : is_convertible<_Yp*, _Tp*>::type { }; template [[__gnu__::__always_inline__]] inline _Tp* __shared_ptr_deref(_Tp* __p) { do { if (std::__is_constant_evaluated() && !bool(__p != nullptr)) std::__glibcxx_assert_fail(); } while (false); return __p; } template::value, bool = is_void<_Tp>::value> class __shared_ptr_access { public: using element_type = _Tp; element_type& operator*() const noexcept { return *std::__shared_ptr_deref(_M_get()); } element_type* operator->() const noexcept { ; return _M_get(); } private: element_type* _M_get() const noexcept { return static_cast*>(this)->get(); } }; template class __shared_ptr_access<_Tp, _Lp, false, true> { public: using element_type = _Tp; element_type* operator->() const noexcept { auto __ptr = static_cast*>(this)->get(); ; return __ptr; } }; template class __shared_ptr_access<_Tp, _Lp, true, false> { public: using element_type = typename remove_extent<_Tp>::type; # 1411 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" element_type& operator[](ptrdiff_t __i) const noexcept { if constexpr (extent<_Tp>::value) do { if (std::__is_constant_evaluated() && !bool(__i < extent<_Tp>::value)) std::__glibcxx_assert_fail(); } while (false); return std::__shared_ptr_deref(_M_get())[__i]; } #pragma GCC diagnostic pop private: element_type* _M_get() const noexcept { return static_cast*>(this)->get(); } }; template class __shared_ptr : public __shared_ptr_access<_Tp, _Lp> { public: using element_type = typename remove_extent<_Tp>::type; private: template using _SafeConv = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; template using _Compatible = typename enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; template using _Assignable = _Compatible<_Yp, __shared_ptr&>; template::pointer> using _UniqCompatible = __enable_if_t<__and_< __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>, is_move_constructible<_Del> >::value, _Res>; template using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; public: using weak_type = __weak_ptr<_Tp, _Lp>; constexpr __shared_ptr() noexcept : _M_ptr(0), _M_refcount() { } template> explicit __shared_ptr(_Yp* __p) : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) { static_assert( !is_void<_Yp>::value, "incomplete type" ); static_assert( sizeof(_Yp) > 0, "incomplete type" ); _M_enable_shared_from_this_with(__p); } template> __shared_ptr(_Yp* __p, _Deleter __d) : _M_ptr(__p), _M_refcount(__p, std::move(__d)) { static_assert(__is_invocable<_Deleter&, _Yp*&>::value, "deleter expression d(p) is well-formed"); _M_enable_shared_from_this_with(__p); } template> __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) { static_assert(__is_invocable<_Deleter&, _Yp*&>::value, "deleter expression d(p) is well-formed"); _M_enable_shared_from_this_with(__p); } template __shared_ptr(nullptr_t __p, _Deleter __d) : _M_ptr(0), _M_refcount(__p, std::move(__d)) { } template __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) { } template __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, element_type* __p) noexcept : _M_ptr(__p), _M_refcount(__r._M_refcount) { } template __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r, element_type* __p) noexcept : _M_ptr(__p), _M_refcount() { _M_refcount._M_swap(__r._M_refcount); __r._M_ptr = nullptr; } __shared_ptr(const __shared_ptr&) noexcept = default; __shared_ptr& operator=(const __shared_ptr&) noexcept = default; ~__shared_ptr() = default; template> __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) { } __shared_ptr(__shared_ptr&& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount() { _M_refcount._M_swap(__r._M_refcount); __r._M_ptr = nullptr; } template> __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount() { _M_refcount._M_swap(__r._M_refcount); __r._M_ptr = nullptr; } template> explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) : _M_refcount(__r._M_refcount) { _M_ptr = __r._M_ptr; } template> __shared_ptr(unique_ptr<_Yp, _Del>&& __r) : _M_ptr(__r.get()), _M_refcount() { auto __raw = std::__to_address(__r.get()); _M_refcount = __shared_count<_Lp>(std::move(__r)); _M_enable_shared_from_this_with(__raw); } # 1592 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template> __shared_ptr(auto_ptr<_Yp>&& __r); #pragma GCC diagnostic pop constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } template _Assignable<_Yp> operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; return *this; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template _Assignable<_Yp> operator=(auto_ptr<_Yp>&& __r) { __shared_ptr(std::move(__r)).swap(*this); return *this; } #pragma GCC diagnostic pop __shared_ptr& operator=(__shared_ptr&& __r) noexcept { __shared_ptr(std::move(__r)).swap(*this); return *this; } template _Assignable<_Yp> operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept { __shared_ptr(std::move(__r)).swap(*this); return *this; } template _UniqAssignable<_Yp, _Del> operator=(unique_ptr<_Yp, _Del>&& __r) { __shared_ptr(std::move(__r)).swap(*this); return *this; } void reset() noexcept { __shared_ptr().swap(*this); } template _SafeConv<_Yp> reset(_Yp* __p) { do { if (std::__is_constant_evaluated() && !bool(__p == nullptr || __p != _M_ptr)) std::__glibcxx_assert_fail(); } while (false); __shared_ptr(__p).swap(*this); } template _SafeConv<_Yp> reset(_Yp* __p, _Deleter __d) { __shared_ptr(__p, std::move(__d)).swap(*this); } template _SafeConv<_Yp> reset(_Yp* __p, _Deleter __d, _Alloc __a) { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } element_type* get() const noexcept { return _M_ptr; } explicit operator bool() const noexcept { return _M_ptr != nullptr; } bool unique() const noexcept { return _M_refcount._M_unique(); } long use_count() const noexcept { return _M_refcount._M_get_use_count(); } void swap(__shared_ptr<_Tp, _Lp>& __other) noexcept { std::swap(_M_ptr, __other._M_ptr); _M_refcount._M_swap(__other._M_refcount); } # 1704 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 template bool owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } template bool owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } protected: template __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) { _M_enable_shared_from_this_with(_M_ptr); } template friend __shared_ptr<_Tp1, _Lp1> __allocate_shared(const _Alloc& __a, _Args&&... __args); # 1738 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept : _M_refcount(__r._M_refcount, std::nothrow) { _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; } friend class __weak_ptr<_Tp, _Lp>; private: template using __esft_base_t = decltype(__enable_shared_from_this_base( std::declval&>(), std::declval<_Yp*>())); template struct __has_esft_base : false_type { }; template struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> : __not_> { }; template::type> typename enable_if<__has_esft_base<_Yp2>::value>::type _M_enable_shared_from_this_with(_Yp* __p) noexcept { if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); } template::type> typename enable_if::value>::type _M_enable_shared_from_this_with(_Yp*) noexcept { } void* _M_get_deleter(const std::type_info& __ti) const noexcept { return _M_refcount._M_get_deleter(__ti); } template friend class __shared_ptr; template friend class __weak_ptr; template friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; template friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; # 1795 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 element_type* _M_ptr; __shared_count<_Lp> _M_refcount; }; template inline bool operator==(const __shared_ptr<_Tp1, _Lp>& __a, const __shared_ptr<_Tp2, _Lp>& __b) noexcept { return __a.get() == __b.get(); } template inline bool operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { return !__a; } # 1827 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 template inline bool operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept { return !__a; } template inline bool operator!=(const __shared_ptr<_Tp1, _Lp>& __a, const __shared_ptr<_Tp2, _Lp>& __b) noexcept { return __a.get() != __b.get(); } template inline bool operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { return (bool)__a; } template inline bool operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept { return (bool)__a; } template inline bool operator<(const __shared_ptr<_Tp, _Lp>& __a, const __shared_ptr<_Up, _Lp>& __b) noexcept { using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type; using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; return less<_Vp>()(__a.get(), __b.get()); } template inline bool operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; return less<_Tp_elt*>()(__a.get(), nullptr); } template inline bool operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept { using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; return less<_Tp_elt*>()(nullptr, __a.get()); } template inline bool operator<=(const __shared_ptr<_Tp1, _Lp>& __a, const __shared_ptr<_Tp2, _Lp>& __b) noexcept { return !(__b < __a); } template inline bool operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { return !(nullptr < __a); } template inline bool operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept { return !(__a < nullptr); } template inline bool operator>(const __shared_ptr<_Tp1, _Lp>& __a, const __shared_ptr<_Tp2, _Lp>& __b) noexcept { return (__b < __a); } template inline bool operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { return nullptr < __a; } template inline bool operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept { return __a < nullptr; } template inline bool operator>=(const __shared_ptr<_Tp1, _Lp>& __a, const __shared_ptr<_Tp2, _Lp>& __b) noexcept { return !(__a < __b); } template inline bool operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { return !(__a < nullptr); } template inline bool operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept { return !(nullptr < __a); } template inline void swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept { __a.swap(__b); } # 1937 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 template inline __shared_ptr<_Tp, _Lp> static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; return _Sp(__r, static_cast(__r.get())); } template inline __shared_ptr<_Tp, _Lp> const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; return _Sp(__r, const_cast(__r.get())); } template inline __shared_ptr<_Tp, _Lp> dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; if (auto* __p = dynamic_cast(__r.get())) return _Sp(__r, __p); return _Sp(); } template inline __shared_ptr<_Tp, _Lp> reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; return _Sp(__r, reinterpret_cast(__r.get())); } template class __weak_ptr { template using _Compatible = typename enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; template using _Assignable = _Compatible<_Yp, __weak_ptr&>; public: using element_type = typename remove_extent<_Tp>::type; constexpr __weak_ptr() noexcept : _M_ptr(nullptr), _M_refcount() { } __weak_ptr(const __weak_ptr&) noexcept = default; ~__weak_ptr() = default; # 2019 "/usr/include/c++/15/bits/shared_ptr_base.h" 3 template> __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept : _M_refcount(__r._M_refcount) { _M_ptr = __r.lock().get(); } template> __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) { } __weak_ptr(__weak_ptr&& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) { __r._M_ptr = nullptr; } template> __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) { __r._M_ptr = nullptr; } __weak_ptr& operator=(const __weak_ptr& __r) noexcept = default; template _Assignable<_Yp> operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept { _M_ptr = __r.lock().get(); _M_refcount = __r._M_refcount; return *this; } template _Assignable<_Yp> operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; return *this; } __weak_ptr& operator=(__weak_ptr&& __r) noexcept { __weak_ptr(std::move(__r)).swap(*this); return *this; } template _Assignable<_Yp> operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept { _M_ptr = __r.lock().get(); _M_refcount = std::move(__r._M_refcount); __r._M_ptr = nullptr; return *this; } __shared_ptr<_Tp, _Lp> lock() const noexcept { return __shared_ptr<_Tp, _Lp>(*this, std::nothrow); } long use_count() const noexcept { return _M_refcount._M_get_use_count(); } bool expired() const noexcept { return _M_refcount._M_get_use_count() == 0; } template bool owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } template bool owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } void reset() noexcept { __weak_ptr().swap(*this); } void swap(__weak_ptr& __s) noexcept { std::swap(_M_ptr, __s._M_ptr); _M_refcount._M_swap(__s._M_refcount); } private: void _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept { if (use_count() == 0) { _M_ptr = __ptr; _M_refcount = __refcount; } } template friend class __shared_ptr; template friend class __weak_ptr; friend class __enable_shared_from_this<_Tp, _Lp>; friend class enable_shared_from_this<_Tp>; element_type* _M_ptr; __weak_count<_Lp> _M_refcount; }; template inline void swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept { __a.swap(__b); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept { return __lhs.owner_before(__rhs); } bool operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept { return __lhs.owner_before(__rhs); } bool operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept { return __lhs.owner_before(__rhs); } }; #pragma GCC diagnostic pop template<> struct _Sp_owner_less { template auto operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept -> decltype(__lhs.owner_before(__rhs)) { return __lhs.owner_before(__rhs); } using is_transparent = void; }; template struct owner_less<__shared_ptr<_Tp, _Lp>> : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> { }; template struct owner_less<__weak_ptr<_Tp, _Lp>> : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> { }; template class __enable_shared_from_this { protected: constexpr __enable_shared_from_this() noexcept { } __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } __enable_shared_from_this& operator=(const __enable_shared_from_this&) noexcept { return *this; } ~__enable_shared_from_this() { } public: __shared_ptr<_Tp, _Lp> shared_from_this() { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } __shared_ptr shared_from_this() const { return __shared_ptr(this->_M_weak_this); } __weak_ptr<_Tp, _Lp> weak_from_this() noexcept { return this->_M_weak_this; } __weak_ptr weak_from_this() const noexcept { return this->_M_weak_this; } private: template void _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept { _M_weak_this._M_assign(__p, __n); } friend const __enable_shared_from_this* __enable_shared_from_this_base(const __shared_count<_Lp>&, const __enable_shared_from_this* __p) { return __p; } template friend class __shared_ptr; mutable __weak_ptr<_Tp, _Lp> _M_weak_this; }; template inline __shared_ptr<_Tp, _Lp> __allocate_shared(const _Alloc& __a, _Args&&... __args) { static_assert(!is_array<_Tp>::value, "make_shared not supported"); return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, std::forward<_Args>(__args)...); } template inline __shared_ptr<_Tp, _Lp> __make_shared(_Args&&... __args) { typedef typename std::remove_const<_Tp>::type _Tp_nc; return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), std::forward<_Args>(__args)...); } template struct hash<__shared_ptr<_Tp, _Lp>> : public __hash_base> { size_t operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept { return hash::element_type*>()( __s.get()); } }; } # 54 "/usr/include/c++/15/bits/shared_ptr.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 68 "/usr/include/c++/15/bits/shared_ptr.h" 3 template inline std::basic_ostream<_Ch, _Tr>& operator<<(std::basic_ostream<_Ch, _Tr>& __os, const __shared_ptr<_Tp, _Lp>& __p) { __os << __p.get(); return __os; } template inline _Del* get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } template inline _Del* get_deleter(const shared_ptr<_Tp>& __p) noexcept { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } # 111 "/usr/include/c++/15/bits/shared_ptr.h" 3 template using _NonArray = __enable_if_t::value, _Tp>; # 174 "/usr/include/c++/15/bits/shared_ptr.h" 3 template class shared_ptr : public __shared_ptr<_Tp> { template using _Constructible = typename enable_if< is_constructible<__shared_ptr<_Tp>, _Args...>::value >::type; template using _Assignable = typename enable_if< is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& >::type; public: using element_type = typename __shared_ptr<_Tp>::element_type; using weak_type = weak_ptr<_Tp>; constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } shared_ptr(const shared_ptr&) noexcept = default; template> explicit shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } # 228 "/usr/include/c++/15/bits/shared_ptr.h" 3 template> shared_ptr(_Yp* __p, _Deleter __d) : __shared_ptr<_Tp>(__p, std::move(__d)) { } # 246 "/usr/include/c++/15/bits/shared_ptr.h" 3 template shared_ptr(nullptr_t __p, _Deleter __d) : __shared_ptr<_Tp>(__p, std::move(__d)) { } # 265 "/usr/include/c++/15/bits/shared_ptr.h" 3 template> shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } # 285 "/usr/include/c++/15/bits/shared_ptr.h" 3 template shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } # 309 "/usr/include/c++/15/bits/shared_ptr.h" 3 template shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept : __shared_ptr<_Tp>(__r, __p) { } # 348 "/usr/include/c++/15/bits/shared_ptr.h" 3 template&>> shared_ptr(const shared_ptr<_Yp>& __r) noexcept : __shared_ptr<_Tp>(__r) { } shared_ptr(shared_ptr&& __r) noexcept : __shared_ptr<_Tp>(std::move(__r)) { } template>> shared_ptr(shared_ptr<_Yp>&& __r) noexcept : __shared_ptr<_Tp>(std::move(__r)) { } # 378 "/usr/include/c++/15/bits/shared_ptr.h" 3 template&>> explicit shared_ptr(const weak_ptr<_Yp>& __r) : __shared_ptr<_Tp>(__r) { } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template>> shared_ptr(auto_ptr<_Yp>&& __r); #pragma GCC diagnostic pop template>> shared_ptr(unique_ptr<_Yp, _Del>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } # 411 "/usr/include/c++/15/bits/shared_ptr.h" 3 constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } shared_ptr& operator=(const shared_ptr&) noexcept = default; template _Assignable&> operator=(const shared_ptr<_Yp>& __r) noexcept { this->__shared_ptr<_Tp>::operator=(__r); return *this; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template _Assignable> operator=(auto_ptr<_Yp>&& __r) { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } #pragma GCC diagnostic pop shared_ptr& operator=(shared_ptr&& __r) noexcept { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } template _Assignable> operator=(shared_ptr<_Yp>&& __r) noexcept { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } template _Assignable> operator=(unique_ptr<_Yp, _Del>&& __r) { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } private: template shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) { } template friend shared_ptr<_NonArray<_Yp>> allocate_shared(const _Alloc&, _Args&&...); template friend shared_ptr<_NonArray<_Yp>> make_shared(_Args&&...); # 534 "/usr/include/c++/15/bits/shared_ptr.h" 3 shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept : __shared_ptr<_Tp>(__r, std::nothrow) { } friend class weak_ptr<_Tp>; }; template shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; template shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; template [[__nodiscard__]] inline bool operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return __a.get() == __b.get(); } template [[__nodiscard__]] inline bool operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { return !__a; } # 579 "/usr/include/c++/15/bits/shared_ptr.h" 3 template [[__nodiscard__]] inline bool operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept { return !__a; } template [[__nodiscard__]] inline bool operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return __a.get() != __b.get(); } template [[__nodiscard__]] inline bool operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { return (bool)__a; } template [[__nodiscard__]] inline bool operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept { return (bool)__a; } template [[__nodiscard__]] inline bool operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { using _Tp_elt = typename shared_ptr<_Tp>::element_type; using _Up_elt = typename shared_ptr<_Up>::element_type; using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; return less<_Vp>()(__a.get(), __b.get()); } template [[__nodiscard__]] inline bool operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { using _Tp_elt = typename shared_ptr<_Tp>::element_type; return less<_Tp_elt*>()(__a.get(), nullptr); } template [[__nodiscard__]] inline bool operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept { using _Tp_elt = typename shared_ptr<_Tp>::element_type; return less<_Tp_elt*>()(nullptr, __a.get()); } template [[__nodiscard__]] inline bool operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return !(__b < __a); } template [[__nodiscard__]] inline bool operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { return !(nullptr < __a); } template [[__nodiscard__]] inline bool operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept { return !(__a < nullptr); } template [[__nodiscard__]] inline bool operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return (__b < __a); } template [[__nodiscard__]] inline bool operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { return nullptr < __a; } template [[__nodiscard__]] inline bool operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept { return __a < nullptr; } template [[__nodiscard__]] inline bool operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return !(__a < __b); } template [[__nodiscard__]] inline bool operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { return !(__a < nullptr); } template [[__nodiscard__]] inline bool operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept { return !(nullptr < __a); } template inline void swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept { __a.swap(__b); } template inline shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(__r, static_cast(__r.get())); } template inline shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(__r, const_cast(__r.get())); } template inline shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; if (auto* __p = dynamic_cast(__r.get())) return _Sp(__r, __p); return _Sp(); } template inline shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(__r, reinterpret_cast(__r.get())); } # 809 "/usr/include/c++/15/bits/shared_ptr.h" 3 template class weak_ptr : public __weak_ptr<_Tp> { template using _Constructible = typename enable_if< is_constructible<__weak_ptr<_Tp>, _Arg>::value >::type; template using _Assignable = typename enable_if< is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& >::type; public: constexpr weak_ptr() noexcept = default; template&>> weak_ptr(const shared_ptr<_Yp>& __r) noexcept : __weak_ptr<_Tp>(__r) { } weak_ptr(const weak_ptr&) noexcept = default; template&>> weak_ptr(const weak_ptr<_Yp>& __r) noexcept : __weak_ptr<_Tp>(__r) { } weak_ptr(weak_ptr&&) noexcept = default; template>> weak_ptr(weak_ptr<_Yp>&& __r) noexcept : __weak_ptr<_Tp>(std::move(__r)) { } weak_ptr& operator=(const weak_ptr& __r) noexcept = default; template _Assignable&> operator=(const weak_ptr<_Yp>& __r) noexcept { this->__weak_ptr<_Tp>::operator=(__r); return *this; } template _Assignable&> operator=(const shared_ptr<_Yp>& __r) noexcept { this->__weak_ptr<_Tp>::operator=(__r); return *this; } weak_ptr& operator=(weak_ptr&& __r) noexcept = default; template _Assignable> operator=(weak_ptr<_Yp>&& __r) noexcept { this->__weak_ptr<_Tp>::operator=(std::move(__r)); return *this; } shared_ptr<_Tp> lock() const noexcept { return shared_ptr<_Tp>(*this, std::nothrow); } }; template weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; template inline void swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept { __a.swap(__b); } template struct owner_less; template<> struct owner_less : _Sp_owner_less { }; template struct owner_less> : public _Sp_owner_less, weak_ptr<_Tp>> { }; template struct owner_less> : public _Sp_owner_less, shared_ptr<_Tp>> { }; template class enable_shared_from_this { protected: constexpr enable_shared_from_this() noexcept { } enable_shared_from_this(const enable_shared_from_this&) noexcept { } enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept { return *this; } ~enable_shared_from_this() { } public: shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(this->_M_weak_this); } shared_ptr shared_from_this() const { return shared_ptr(this->_M_weak_this); } weak_ptr<_Tp> weak_from_this() noexcept { return this->_M_weak_this; } weak_ptr weak_from_this() const noexcept { return this->_M_weak_this; } private: template void _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept { _M_weak_this._M_assign(__p, __n); } friend const enable_shared_from_this* __enable_shared_from_this_base(const __shared_count<>&, const enable_shared_from_this* __p) { return __p; } template friend class __shared_ptr; mutable weak_ptr<_Tp> _M_weak_this; }; # 986 "/usr/include/c++/15/bits/shared_ptr.h" 3 template inline shared_ptr<_NonArray<_Tp>> allocate_shared(const _Alloc& __a, _Args&&... __args) { return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, std::forward<_Args>(__args)...); } # 1001 "/usr/include/c++/15/bits/shared_ptr.h" 3 template inline shared_ptr<_NonArray<_Tp>> make_shared(_Args&&... __args) { using _Alloc = allocator; _Alloc __a; return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, std::forward<_Args>(__args)...); } # 1150 "/usr/include/c++/15/bits/shared_ptr.h" 3 template struct hash> : public __hash_base> { size_t operator()(const shared_ptr<_Tp>& __s) const noexcept { return std::hash::element_type*>()(__s.get()); } }; template constexpr bool __is_shared_ptr = false; template constexpr bool __is_shared_ptr> = true; namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::true_type { }; template struct _Never_valueless_alt> : std::true_type { }; } } # 83 "/usr/include/c++/15/memory" 2 3 # 1 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 1 3 # 62 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 74 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 struct _Sp_locker { _Sp_locker(const _Sp_locker&) = delete; _Sp_locker& operator=(const _Sp_locker&) = delete; explicit _Sp_locker(const void*) noexcept; _Sp_locker(const void*, const void*) noexcept; ~_Sp_locker(); private: unsigned char _M_key1; unsigned char _M_key2; }; # 101 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 template inline bool atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>*) { return __gthread_active_p() == 0; } template inline bool atomic_is_lock_free(const shared_ptr<_Tp>* __p) { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } # 130 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 template inline shared_ptr<_Tp> atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) { _Sp_locker __lock{__p}; return *__p; } template inline shared_ptr<_Tp> atomic_load(const shared_ptr<_Tp>* __p) { return std::atomic_load_explicit(__p, memory_order_seq_cst); } template inline __shared_ptr<_Tp, _Lp> atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order) { _Sp_locker __lock{__p}; return *__p; } template inline __shared_ptr<_Tp, _Lp> atomic_load(const __shared_ptr<_Tp, _Lp>* __p) { return std::atomic_load_explicit(__p, memory_order_seq_cst); } # 170 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 template inline void atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); } template inline void atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } template inline void atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); } template inline void atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } # 211 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 template inline shared_ptr<_Tp> atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); return __r; } template inline shared_ptr<_Tp> atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) { return std::atomic_exchange_explicit(__p, std::move(__r), memory_order_seq_cst); } template inline __shared_ptr<_Tp, _Lp> atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); return __r; } template inline __shared_ptr<_Tp, _Lp> atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) { return std::atomic_exchange_explicit(__p, std::move(__r), memory_order_seq_cst); } # 264 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 template bool atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) { shared_ptr<_Tp> __x; _Sp_locker __lock{__p, __v}; owner_less> __less; if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) { __x = std::move(*__p); *__p = std::move(__w); return true; } __x = std::move(*__v); *__v = *__p; return false; } template inline bool atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order __success, memory_order __failure) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), __success, __failure); } template inline bool atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) { return std::atomic_compare_exchange_weak_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } template bool atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w, memory_order, memory_order) { __shared_ptr<_Tp, _Lp> __x; _Sp_locker __lock{__p, __v}; owner_less<__shared_ptr<_Tp, _Lp>> __less; if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) { __x = std::move(*__p); *__p = std::move(__w); return true; } __x = std::move(*__v); *__v = *__p; return false; } template inline bool atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w, memory_order __success, memory_order __failure) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), __success, __failure); } template inline bool atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w) { return std::atomic_compare_exchange_weak_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } # 868 "/usr/include/c++/15/bits/shared_ptr_atomic.h" 3 } # 84 "/usr/include/c++/15/memory" 2 3 # 1 "/usr/include/c++/15/backward/auto_ptr.h" 1 3 # 36 "/usr/include/c++/15/backward/auto_ptr.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 47 "/usr/include/c++/15/backward/auto_ptr.h" 3 template struct auto_ptr_ref { _Tp1* _M_ptr; explicit auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } } __attribute__ ((__deprecated__)); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" # 92 "/usr/include/c++/15/backward/auto_ptr.h" 3 template class auto_ptr { private: _Tp* _M_ptr; public: typedef _Tp element_type; explicit auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } # 118 "/usr/include/c++/15/backward/auto_ptr.h" 3 auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } # 130 "/usr/include/c++/15/backward/auto_ptr.h" 3 template auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } # 141 "/usr/include/c++/15/backward/auto_ptr.h" 3 auto_ptr& operator=(auto_ptr& __a) throw() { reset(__a.release()); return *this; } # 158 "/usr/include/c++/15/backward/auto_ptr.h" 3 template auto_ptr& operator=(auto_ptr<_Tp1>& __a) throw() { reset(__a.release()); return *this; } # 176 "/usr/include/c++/15/backward/auto_ptr.h" 3 ~auto_ptr() { delete _M_ptr; } # 186 "/usr/include/c++/15/backward/auto_ptr.h" 3 element_type& operator*() const throw() { do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) std::__glibcxx_assert_fail(); } while (false); return *_M_ptr; } element_type* operator->() const throw() { do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) std::__glibcxx_assert_fail(); } while (false); return _M_ptr; } # 216 "/usr/include/c++/15/backward/auto_ptr.h" 3 element_type* get() const throw() { return _M_ptr; } # 230 "/usr/include/c++/15/backward/auto_ptr.h" 3 element_type* release() throw() { element_type* __tmp = _M_ptr; _M_ptr = 0; return __tmp; } # 245 "/usr/include/c++/15/backward/auto_ptr.h" 3 void reset(element_type* __p = 0) throw() { if (__p != _M_ptr) { delete _M_ptr; _M_ptr = __p; } } # 270 "/usr/include/c++/15/backward/auto_ptr.h" 3 auto_ptr(auto_ptr_ref __ref) throw() : _M_ptr(__ref._M_ptr) { } auto_ptr& operator=(auto_ptr_ref __ref) throw() { if (__ref._M_ptr != this->get()) { delete _M_ptr; _M_ptr = __ref._M_ptr; } return *this; } template operator auto_ptr_ref<_Tp1>() throw() { return auto_ptr_ref<_Tp1>(this->release()); } template operator auto_ptr<_Tp1>() throw() { return auto_ptr<_Tp1>(this->release()); } } __attribute__ ((__deprecated__ ("use '" "std::unique_ptr" "' instead"))); template<> class auto_ptr { public: typedef void element_type; } __attribute__ ((__deprecated__)); template<_Lock_policy _Lp> template inline __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r) : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) { __r.release(); } template template inline __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r) : _M_ptr(__r.get()), _M_refcount() { static_assert( sizeof(_Tp1) > 0, "incomplete type" ); _Tp1* __tmp = __r.get(); _M_refcount = __shared_count<_Lp>(std::move(__r)); _M_enable_shared_from_this_with(__tmp); } template template inline shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } template template inline unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept : _M_t(__u.release(), deleter_type()) { } #pragma GCC diagnostic pop } # 89 "/usr/include/c++/15/memory" 2 3 # 118 "/usr/include/c++/15/memory" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 119 "/usr/include/c++/15/memory" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 139 "/usr/include/c++/15/memory" 3 enum class pointer_safety { relaxed, preferred, strict }; inline void declare_reachable(void*) { } template inline _Tp* undeclare_reachable(_Tp* __p) { return __p; } 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; } } # 174 "/usr/include/c++/15/memory" 3 # 1 "/usr/include/c++/15/pstl/glue_memory_defs.h" 1 3 # 13 "/usr/include/c++/15/pstl/glue_memory_defs.h" 3 # 1 "/usr/include/c++/15/pstl/execution_defs.h" 1 3 # 15 "/usr/include/c++/15/pstl/execution_defs.h" 3 namespace __pstl { namespace execution { inline namespace v1 { class sequenced_policy { }; class parallel_policy { }; class parallel_unsequenced_policy { }; class unsequenced_policy { }; inline constexpr sequenced_policy seq{}; inline constexpr parallel_policy par{}; inline constexpr parallel_unsequenced_policy par_unseq{}; inline constexpr unsequenced_policy unseq{}; template struct is_execution_policy : std::false_type { }; template <> struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type { }; template <> struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type { }; template <> struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type { }; template <> struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type { }; template constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value; } } namespace __internal { template using __enable_if_execution_policy = typename std::enable_if<__pstl::execution::is_execution_policy>::value, _Tp>::type; template struct __serial_tag; template struct __parallel_tag; } } # 14 "/usr/include/c++/15/pstl/glue_memory_defs.h" 2 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); } # 175 "/usr/include/c++/15/memory" 2 3 # 6 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Backtrace.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Lazy.h" 1 # 6 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Lazy.h" namespace c10 { # 16 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Lazy.h" template class OptimisticLazy { public: OptimisticLazy() = default; OptimisticLazy(const OptimisticLazy& other) { if (T* value = other.value_.load(std::memory_order_acquire)) { value_ = new T(*value); } } OptimisticLazy(OptimisticLazy&& other) noexcept : value_(other.value_.exchange(nullptr, std::memory_order_acq_rel)) {} ~OptimisticLazy() { reset(); } template T& ensure(const Factory& factory) { if (T* value = value_.load(std::memory_order_acquire)) { return *value; } T* value = new T(factory()); T* old = nullptr; if (!value_.compare_exchange_strong( old, value, std::memory_order_release, std::memory_order_acquire)) { delete value; value = old; } return *value; } OptimisticLazy& operator=(const OptimisticLazy& other) { *this = OptimisticLazy{other}; return *this; } OptimisticLazy& operator=(OptimisticLazy&& other) noexcept { if (this != &other) { reset(); value_.store( other.value_.exchange(nullptr, std::memory_order_acquire), std::memory_order_release); } return *this; } void reset() { if (T* old = value_.load(std::memory_order_relaxed)) { value_.store(nullptr, std::memory_order_relaxed); delete old; } } private: std::atomic value_{nullptr}; }; template class LazyValue { public: virtual ~LazyValue() = default; virtual const T& get() const = 0; }; template class OptimisticLazyValue : public LazyValue { public: const T& get() const override { return value_.ensure([this] { return compute(); }); } private: virtual T compute() const = 0; mutable OptimisticLazy value_; }; template class PrecomputedLazyValue : public LazyValue { public: PrecomputedLazyValue(T value) : value_(std::move(value)) {} const T& get() const override { return value_; } private: T value_; }; } # 11 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Backtrace.h" 2 namespace c10 { using Backtrace = std::shared_ptr>; __attribute__((__visibility__("default"))) std::string get_backtrace( size_t frames_to_skip = 0, size_t maximum_number_of_frames = 64, bool skip_python_frames = true); __attribute__((__visibility__("default"))) Backtrace get_lazy_backtrace( size_t frames_to_skip = 0, size_t maximum_number_of_frames = 64, bool skip_python_frames = true); } # 7 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/StringUtil.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_utils.h" 1 namespace c10 { using std::stod; using std::stoi; using std::stoll; using std::stoull; using std::to_string; } # 6 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/StringUtil.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" 1 # 1 "/usr/include/c++/15/algorithm" 1 3 # 63 "/usr/include/c++/15/algorithm" 3 # 1 "/usr/include/c++/15/bits/stl_algo.h" 1 3 # 59 "/usr/include/c++/15/bits/stl_algo.h" 3 # 1 "/usr/include/c++/15/bits/algorithmfwd.h" 1 3 # 44 "/usr/include/c++/15/bits/algorithmfwd.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { # 200 "/usr/include/c++/15/bits/algorithmfwd.h" 3 template bool all_of(_IIter, _IIter, _Predicate); template bool any_of(_IIter, _IIter, _Predicate); template bool binary_search(_FIter, _FIter, const _Tp&); template bool binary_search(_FIter, _FIter, const _Tp&, _Compare); template constexpr const _Tp& clamp(const _Tp&, const _Tp&, const _Tp&); template constexpr const _Tp& clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); template _OIter copy(_IIter, _IIter, _OIter); template _BIter2 copy_backward(_BIter1, _BIter1, _BIter2); template _OIter copy_if(_IIter, _IIter, _OIter, _Predicate); template _OIter copy_n(_IIter, _Size, _OIter); template pair<_FIter, _FIter> equal_range(_FIter, _FIter, const _Tp&); template pair<_FIter, _FIter> equal_range(_FIter, _FIter, const _Tp&, _Compare); template void fill(_FIter, _FIter, const _Tp&); template _OIter fill_n(_OIter, _Size, const _Tp&); template _FIter1 find_end(_FIter1, _FIter1, _FIter2, _FIter2); template _FIter1 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); template _IIter find_if_not(_IIter, _IIter, _Predicate); template bool includes(_IIter1, _IIter1, _IIter2, _IIter2); template bool includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); template void inplace_merge(_BIter, _BIter, _BIter); template void inplace_merge(_BIter, _BIter, _BIter, _Compare); template bool is_heap(_RAIter, _RAIter); template bool is_heap(_RAIter, _RAIter, _Compare); template _RAIter is_heap_until(_RAIter, _RAIter); template _RAIter is_heap_until(_RAIter, _RAIter, _Compare); template bool is_partitioned(_IIter, _IIter, _Predicate); template bool is_permutation(_FIter1, _FIter1, _FIter2); template bool is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); template bool is_sorted(_FIter, _FIter); template bool is_sorted(_FIter, _FIter, _Compare); template _FIter is_sorted_until(_FIter, _FIter); template _FIter is_sorted_until(_FIter, _FIter, _Compare); template void iter_swap(_FIter1, _FIter2); template _FIter lower_bound(_FIter, _FIter, const _Tp&); template _FIter lower_bound(_FIter, _FIter, const _Tp&, _Compare); template void make_heap(_RAIter, _RAIter); template void make_heap(_RAIter, _RAIter, _Compare); template constexpr const _Tp& max(const _Tp&, const _Tp&); template constexpr const _Tp& max(const _Tp&, const _Tp&, _Compare); template constexpr const _Tp& min(const _Tp&, const _Tp&); template constexpr const _Tp& min(const _Tp&, const _Tp&, _Compare); template constexpr pair minmax(const _Tp&, const _Tp&); template constexpr pair minmax(const _Tp&, const _Tp&, _Compare); template constexpr pair<_FIter, _FIter> minmax_element(_FIter, _FIter); template constexpr pair<_FIter, _FIter> minmax_element(_FIter, _FIter, _Compare); template constexpr _Tp min(initializer_list<_Tp>); template constexpr _Tp min(initializer_list<_Tp>, _Compare); template constexpr _Tp max(initializer_list<_Tp>); template constexpr _Tp max(initializer_list<_Tp>, _Compare); template constexpr pair<_Tp, _Tp> minmax(initializer_list<_Tp>); template constexpr pair<_Tp, _Tp> minmax(initializer_list<_Tp>, _Compare); template bool next_permutation(_BIter, _BIter); template bool next_permutation(_BIter, _BIter, _Compare); template bool none_of(_IIter, _IIter, _Predicate); template _RAIter partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); template _RAIter partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); template pair<_OIter1, _OIter2> partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); template _FIter partition_point(_FIter, _FIter, _Predicate); template void pop_heap(_RAIter, _RAIter); template void pop_heap(_RAIter, _RAIter, _Compare); template bool prev_permutation(_BIter, _BIter); template bool prev_permutation(_BIter, _BIter, _Compare); template void push_heap(_RAIter, _RAIter); template void push_heap(_RAIter, _RAIter, _Compare); template _FIter remove(_FIter, _FIter, const _Tp&); template _FIter remove_if(_FIter, _FIter, _Predicate); template _OIter remove_copy(_IIter, _IIter, _OIter, const _Tp&); template _OIter remove_copy_if(_IIter, _IIter, _OIter, _Predicate); template _OIter replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); template _OIter replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); template void reverse(_BIter, _BIter); template _OIter reverse_copy(_BIter, _BIter, _OIter); inline namespace _V2 { template _FIter rotate(_FIter, _FIter, _FIter); } template _OIter rotate_copy(_FIter, _FIter, _FIter, _OIter); # 635 "/usr/include/c++/15/bits/algorithmfwd.h" 3 template void shuffle(_RAIter, _RAIter, _UGenerator&&); template void sort_heap(_RAIter, _RAIter); template void sort_heap(_RAIter, _RAIter, _Compare); template _BIter stable_partition(_BIter, _BIter, _Predicate); # 671 "/usr/include/c++/15/bits/algorithmfwd.h" 3 template _FIter2 swap_ranges(_FIter1, _FIter1, _FIter2); template _FIter unique(_FIter, _FIter); template _FIter unique(_FIter, _FIter, _BinaryPredicate); template _FIter upper_bound(_FIter, _FIter, const _Tp&); template _FIter upper_bound(_FIter, _FIter, const _Tp&, _Compare); template _FIter adjacent_find(_FIter, _FIter); template _FIter adjacent_find(_FIter, _FIter, _BinaryPredicate); template typename iterator_traits<_IIter>::difference_type count(_IIter, _IIter, const _Tp&); template typename iterator_traits<_IIter>::difference_type count_if(_IIter, _IIter, _Predicate); template bool equal(_IIter1, _IIter1, _IIter2); template bool equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); template _IIter find(_IIter, _IIter, const _Tp&); template _FIter1 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); template _FIter1 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); template _IIter find_if(_IIter, _IIter, _Predicate); template _Funct for_each(_IIter, _IIter, _Funct); template void generate(_FIter, _FIter, _Generator); template _OIter generate_n(_OIter, _Size, _Generator); template bool lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); template bool lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); template constexpr _FIter max_element(_FIter, _FIter); template constexpr _FIter max_element(_FIter, _FIter, _Compare); template _OIter merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template _OIter merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template constexpr _FIter min_element(_FIter, _FIter); template constexpr _FIter min_element(_FIter, _FIter, _Compare); template pair<_IIter1, _IIter2> mismatch(_IIter1, _IIter1, _IIter2); template pair<_IIter1, _IIter2> mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); template void nth_element(_RAIter, _RAIter, _RAIter); template void nth_element(_RAIter, _RAIter, _RAIter, _Compare); template void partial_sort(_RAIter, _RAIter, _RAIter); template void partial_sort(_RAIter, _RAIter, _RAIter, _Compare); template _BIter partition(_BIter, _BIter, _Predicate); template __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) void random_shuffle(_RAIter, _RAIter); template __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) void random_shuffle(_RAIter, _RAIter, _Generator&&); template void replace(_FIter, _FIter, const _Tp&, const _Tp&); template void replace_if(_FIter, _FIter, _Predicate, const _Tp&); template _FIter1 search(_FIter1, _FIter1, _FIter2, _FIter2); template _FIter1 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); template _FIter search_n(_FIter, _FIter, _Size, const _Tp&); template _FIter search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); template _OIter set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template _OIter set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template _OIter set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template _OIter set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template _OIter set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template _OIter set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template _OIter set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template _OIter set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template void sort(_RAIter, _RAIter); template void sort(_RAIter, _RAIter, _Compare); template void stable_sort(_RAIter, _RAIter); template void stable_sort(_RAIter, _RAIter, _Compare); template _OIter transform(_IIter, _IIter, _OIter, _UnaryOperation); template _OIter transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); template _OIter unique_copy(_IIter, _IIter, _OIter); template _OIter unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); } #pragma GCC diagnostic pop # 60 "/usr/include/c++/15/bits/stl_algo.h" 2 3 # 1 "/usr/include/c++/15/bits/stl_heap.h" 1 3 # 63 "/usr/include/c++/15/bits/stl_heap.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template _Distance __is_heap_until(_RandomAccessIterator __first, _Distance __n, _Compare& __comp) { _Distance __parent = 0; for (_Distance __child = 1; __child < __n; ++__child) { if (__comp(__first + __parent, __first + __child)) return __child; if ((__child & 1) == 0) ++__parent; } return __n; } template inline bool __is_heap(_RandomAccessIterator __first, _Distance __n) { __gnu_cxx::__ops::_Iter_less_iter __comp; return std::__is_heap_until(__first, __n, __comp) == __n; } template inline bool __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) { typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); return std::__is_heap_until(__first, __n, __cmp) == __n; } template inline bool __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { return std::__is_heap(__first, std::distance(__first, __last)); } template inline bool __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { return std::__is_heap(__first, std::move(__comp), std::distance(__first, __last)); } template void __push_heap(_RandomAccessIterator __first, _Distance __holeIndex, _Distance __topIndex, _Tp __value, _Compare& __comp) { _Distance __parent = (__holeIndex - 1) / 2; while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) { *(__first + __holeIndex) = std::move(*(__first + __parent)); __holeIndex = __parent; __parent = (__holeIndex - 1) / 2; } *(__first + __holeIndex) = std::move(__value); } # 159 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; ; ; __gnu_cxx::__ops::_Iter_less_val __comp; _ValueType __value = std::move(*(__last - 1)); std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), std::move(__value), __comp); } # 195 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; ; ; __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) __cmp(std::move(__comp)); _ValueType __value = std::move(*(__last - 1)); std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), std::move(__value), __cmp); } template void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, _Distance __len, _Tp __value, _Compare __comp) { const _Distance __topIndex = __holeIndex; _Distance __secondChild = __holeIndex; while (__secondChild < (__len - 1) / 2) { __secondChild = 2 * (__secondChild + 1); if (__comp(__first + __secondChild, __first + (__secondChild - 1))) __secondChild--; *(__first + __holeIndex) = std::move(*(__first + __secondChild)); __holeIndex = __secondChild; } if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) { __secondChild = 2 * (__secondChild + 1); *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1))) ; __holeIndex = __secondChild - 1; } __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) __cmp(std::move(__comp)); std::__push_heap(__first, __holeIndex, __topIndex, std::move(__value), __cmp); } template inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __result, _Compare& __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; _ValueType __value = std::move(*__result); *__result = std::move(*__first); std::__adjust_heap(__first, _DistanceType(0), _DistanceType(__last - __first), std::move(__value), __comp); } # 280 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } while (false); ; ; ; if (__last - __first > 1) { --__last; __gnu_cxx::__ops::_Iter_less_iter __comp; std::__pop_heap(__first, __last, __last, __comp); } } # 314 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } while (false); ; if (__last - __first > 1) { typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); --__last; std::__pop_heap(__first, __last, __last, __cmp); } } template void __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; if (__last - __first < 2) return; const _DistanceType __len = __last - __first; _DistanceType __parent = (__len - 2) / 2; while (true) { _ValueType __value = std::move(*(__first + __parent)); std::__adjust_heap(__first, __parent, __len, std::move(__value), __comp); if (__parent == 0) return; __parent--; } } # 372 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; __gnu_cxx::__ops::_Iter_less_iter __comp; std::__make_heap(__first, __last, __comp); } # 399 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); std::__make_heap(__first, __last, __cmp); } template void __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) { while (__last - __first > 1) { --__last; std::__pop_heap(__first, __last, __last, __comp); } } # 437 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; ; __gnu_cxx::__ops::_Iter_less_iter __comp; std::__sort_heap(__first, __last, __comp); } # 465 "/usr/include/c++/15/bits/stl_heap.h" 3 template inline void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; ; typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); std::__sort_heap(__first, __last, __cmp); } # 494 "/usr/include/c++/15/bits/stl_heap.h" 3 template [[__nodiscard__]] inline _RandomAccessIterator is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; __gnu_cxx::__ops::_Iter_less_iter __comp; return __first + std::__is_heap_until(__first, std::distance(__first, __last), __comp); } # 523 "/usr/include/c++/15/bits/stl_heap.h" 3 template [[__nodiscard__]] inline _RandomAccessIterator is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); return __first + std::__is_heap_until(__first, std::distance(__first, __last), __cmp); } # 548 "/usr/include/c++/15/bits/stl_heap.h" 3 template [[__nodiscard__]] inline bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { return std::is_heap_until(__first, __last) == __last; } # 562 "/usr/include/c++/15/bits/stl_heap.h" 3 template [[__nodiscard__]] inline bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; const auto __dist = std::distance(__first, __last); typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); return std::__is_heap_until(__first, __dist, __cmp) == __dist; } } # 62 "/usr/include/c++/15/bits/stl_algo.h" 2 3 # 1 "/usr/include/c++/15/bits/uniform_int_dist.h" 1 3 # 41 "/usr/include/c++/15/bits/uniform_int_dist.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 64 "/usr/include/c++/15/bits/uniform_int_dist.h" 3 namespace __detail { template constexpr bool _Power_of_2(_Tp __x) { return ((__x - 1) & __x) == 0; } } # 87 "/usr/include/c++/15/bits/uniform_int_dist.h" 3 template class uniform_int_distribution { static_assert(std::is_integral<_IntType>::value, "template argument must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef uniform_int_distribution<_IntType> distribution_type; param_type() : param_type(0) { } explicit param_type(_IntType __a, _IntType __b = __gnu_cxx::__int_traits<_IntType>::__max) : _M_a(__a), _M_b(__b) { do { if (std::__is_constant_evaluated() && !bool(_M_a <= _M_b)) std::__glibcxx_assert_fail(); } while (false); } result_type a() const { return _M_a; } result_type b() const { return _M_b; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _IntType _M_a; _IntType _M_b; }; public: uniform_int_distribution() : uniform_int_distribution(0) { } explicit uniform_int_distribution(_IntType __a, _IntType __b = __gnu_cxx::__int_traits<_IntType>::__max) : _M_param(__a, __b) { } explicit uniform_int_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } result_type a() const { return _M_param.a(); } result_type b() const { return _M_param.b(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return this->a(); } result_type max() const { return this->b(); } template result_type operator()(_UniformRandomBitGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomBitGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomBitGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomBitGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomBitGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const uniform_int_distribution& __d1, const uniform_int_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomBitGenerator& __urng, const param_type& __p); param_type _M_param; template static _Up _S_nd(_Urbg& __g, _Up __range) { using _Up_traits = __gnu_cxx::__int_traits<_Up>; using _Wp_traits = __gnu_cxx::__int_traits<_Wp>; static_assert(!_Up_traits::__is_signed, "U must be unsigned"); static_assert(!_Wp_traits::__is_signed, "W must be unsigned"); static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits), "W must be twice as wide as U"); _Wp __product = _Wp(__g()) * _Wp(__range); _Up __low = _Up(__product); if (__low < __range) { _Up __threshold = -__range % __range; while (__low < __threshold) { __product = _Wp(__g()) * _Wp(__range); __low = _Up(__product); } } return __product >> _Up_traits::__digits; } }; template template typename uniform_int_distribution<_IntType>::result_type uniform_int_distribution<_IntType>:: operator()(_UniformRandomBitGenerator& __urng, const param_type& __param) { typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; typedef typename make_unsigned::type __utype; typedef typename common_type<_Gresult_type, __utype>::type __uctype; constexpr __uctype __urngmin = _UniformRandomBitGenerator::min(); constexpr __uctype __urngmax = _UniformRandomBitGenerator::max(); static_assert( __urngmin < __urngmax, "Uniform random bit generator must define min() < max()"); constexpr __uctype __urngrange = __urngmax - __urngmin; const __uctype __urange = __uctype(__param.b()) - __uctype(__param.a()); __uctype __ret; if (__urngrange > __urange) { const __uctype __uerange = __urange + 1; if constexpr (__urngrange == 0xffffffffffffffffUL) { long unsigned int __u64erange = __uerange; __ret = __extension__ _S_nd(__urng, __u64erange); } else if constexpr (__urngrange == 0xffffffffU) { unsigned int __u32erange = __uerange; __ret = _S_nd(__urng, __u32erange); } else { const __uctype __scaling = __urngrange / __uerange; const __uctype __past = __uerange * __scaling; do __ret = __uctype(__urng()) - __urngmin; while (__ret >= __past); __ret /= __scaling; } } else if (__urngrange < __urange) { # 359 "/usr/include/c++/15/bits/uniform_int_dist.h" 3 __uctype __tmp; do { const __uctype __uerngrange = __urngrange + 1; __tmp = (__uerngrange * operator() (__urng, param_type(0, __urange / __uerngrange))); __ret = __tmp + (__uctype(__urng()) - __urngmin); } while (__ret > __urange || __ret < __tmp); } else __ret = __uctype(__urng()) - __urngmin; return __ret + __param.a(); } template template void uniform_int_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomBitGenerator& __urng, const param_type& __param) { typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; typedef typename make_unsigned::type __utype; typedef typename common_type<_Gresult_type, __utype>::type __uctype; static_assert( __urng.min() < __urng.max(), "Uniform random bit generator must define min() < max()"); constexpr __uctype __urngmin = __urng.min(); constexpr __uctype __urngmax = __urng.max(); constexpr __uctype __urngrange = __urngmax - __urngmin; const __uctype __urange = __uctype(__param.b()) - __uctype(__param.a()); __uctype __ret; if (__urngrange > __urange) { if (__detail::_Power_of_2(__urngrange + 1) && __detail::_Power_of_2(__urange + 1)) { while (__f != __t) { __ret = __uctype(__urng()) - __urngmin; *__f++ = (__ret & __urange) + __param.a(); } } else { const __uctype __uerange = __urange + 1; const __uctype __scaling = __urngrange / __uerange; const __uctype __past = __uerange * __scaling; while (__f != __t) { do __ret = __uctype(__urng()) - __urngmin; while (__ret >= __past); *__f++ = __ret / __scaling + __param.a(); } } } else if (__urngrange < __urange) { # 444 "/usr/include/c++/15/bits/uniform_int_dist.h" 3 __uctype __tmp; while (__f != __t) { do { constexpr __uctype __uerngrange = __urngrange + 1; __tmp = (__uerngrange * operator() (__urng, param_type(0, __urange / __uerngrange))); __ret = __tmp + (__uctype(__urng()) - __urngmin); } while (__ret > __urange || __ret < __tmp); *__f++ = __ret; } } else while (__f != __t) *__f++ = __uctype(__urng()) - __urngmin + __param.a(); } } # 66 "/usr/include/c++/15/bits/stl_algo.h" 2 3 # 75 "/usr/include/c++/15/bits/stl_algo.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template void __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b, _Iterator __c, _Compare __comp) { if (__comp(__a, __b)) { if (__comp(__b, __c)) std::iter_swap(__result, __b); else if (__comp(__a, __c)) std::iter_swap(__result, __c); else std::iter_swap(__result, __a); } else if (__comp(__a, __c)) std::iter_swap(__result, __a); else if (__comp(__b, __c)) std::iter_swap(__result, __c); else std::iter_swap(__result, __b); } template inline _InputIterator __find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return std::__find_if(__first, __last, __gnu_cxx::__ops::__negate(__pred)); } template _InputIterator __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) { for (; __len; --__len, (void) ++__first) if (!__pred(__first)) break; return __first; } # 150 "/usr/include/c++/15/bits/stl_algo.h" 3 template _ForwardIterator __search_n_aux(_ForwardIterator __first, _ForwardIterator __last, _Integer __count, _UnaryPredicate __unary_pred, std::forward_iterator_tag) { __first = std::__find_if(__first, __last, __unary_pred); while (__first != __last) { typename iterator_traits<_ForwardIterator>::difference_type __n = __count; _ForwardIterator __i = __first; ++__i; while (__i != __last && __n != 1 && __unary_pred(__i)) { ++__i; --__n; } if (__n == 1) return __first; if (__i == __last) return __last; __first = std::__find_if(++__i, __last, __unary_pred); } return __last; } template _RandomAccessIter __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last, _Integer __count, _UnaryPredicate __unary_pred, std::random_access_iterator_tag) { typedef typename std::iterator_traits<_RandomAccessIter>::difference_type _DistanceType; _DistanceType __tailSize = __last - __first; _DistanceType __remainder = __count; while (__remainder <= __tailSize) { __first += __remainder; __tailSize -= __remainder; _RandomAccessIter __backTrack = __first; while (__unary_pred(--__backTrack)) { if (--__remainder == 0) return (__first - __count); } __remainder = __count + 1 - (__first - __backTrack); } return __last; } template _ForwardIterator __search_n(_ForwardIterator __first, _ForwardIterator __last, _Integer __count, _UnaryPredicate __unary_pred) { if (__count <= 0) return __first; if (__count == 1) return std::__find_if(__first, __last, __unary_pred); return std::__search_n_aux(__first, __last, __count, __unary_pred, std::__iterator_category(__first)); } template _ForwardIterator1 __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, forward_iterator_tag, forward_iterator_tag, _BinaryPredicate __comp) { if (__first2 == __last2) return __last1; _ForwardIterator1 __result = __last1; while (1) { _ForwardIterator1 __new_result = std::__search(__first1, __last1, __first2, __last2, __comp); if (__new_result == __last1) return __result; else { __result = __new_result; __first1 = __new_result; ++__first1; } } } template _BidirectionalIterator1 __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, bidirectional_iterator_tag, bidirectional_iterator_tag, _BinaryPredicate __comp) { typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; _RevIterator1 __rlast1(__first1); _RevIterator2 __rlast2(__first2); _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1, _RevIterator2(__last2), __rlast2, __comp); if (__rresult == __rlast1) return __last1; else { _BidirectionalIterator1 __result = __rresult.base(); std::advance(__result, -std::distance(__first2, __last2)); return __result; } } # 324 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { ; ; return std::__find_end(__first1, __last1, __first2, __last2, std::__iterator_category(__first1), std::__iterator_category(__first2), __gnu_cxx::__ops::__iter_equal_to_iter()); } # 373 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __comp) { ; ; return std::__find_end(__first1, __last1, __first2, __last2, std::__iterator_category(__first1), std::__iterator_category(__first2), __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 409 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return __last == std::find_if_not(__first, __last, __pred); } # 427 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return __last == std::find_if(__first, __last, __pred); } # 446 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return !std::none_of(__first, __last, __pred); } # 462 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _InputIterator find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) { ; return std::__find_if_not(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } # 487 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) { __first = std::find_if_not(__first, __last, __pred); if (__first == __last) return true; ++__first; return std::none_of(__first, __last, __pred); } # 509 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] _ForwardIterator partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; _DistanceType __len = std::distance(__first, __last); while (__len > 0) { _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); if (__pred(*__middle)) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; } template _OutputIterator __remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) { for (; __first != __last; ++__first) if (!__pred(__first)) { *__result = *__first; ++__result; } return __result; } # 576 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value) { ; return std::__remove_copy_if(__first, __last, __result, __gnu_cxx::__ops::__iter_equals_val(__value)); } # 609 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) { ; return std::__remove_copy_if(__first, __last, __result, __gnu_cxx::__ops::__pred_iter(__pred)); } # 644 "/usr/include/c++/15/bits/stl_algo.h" 3 template _OutputIterator copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) { ; for (; __first != __last; ++__first) if (__pred(*__first)) { *__result = *__first; ++__result; } return __result; } # 681 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) { const auto __n2 = std::__size_to_integer(__n); if (__n2 <= 0) return __result; ; ; auto __res = std::__copy_n_a(std::__niter_base(__first), __n2, std::__niter_base(__result), true); return std::__niter_wrap(__result, std::move(__res)); } # 718 "/usr/include/c++/15/bits/stl_algo.h" 3 template pair<_OutputIterator1, _OutputIterator2> partition_copy(_InputIterator __first, _InputIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _Predicate __pred) { ; for (; __first != __last; ++__first) if (__pred(*__first)) { *__out_true = *__first; ++__out_true; } else { *__out_false = *__first; ++__out_false; } return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); } # 769 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { ; return std::__remove_if(__first, __last, __gnu_cxx::__ops::__iter_equals_val(__value)); } # 803 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__remove_if(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } template _ForwardIterator __adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred) { if (__first == __last) return __last; _ForwardIterator __next = __first; while (++__next != __last) { if (__binary_pred(__first, __next)) return __first; __first = __next; } return __last; } template _ForwardIterator __unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred) { __first = std::__adjacent_find(__first, __last, __binary_pred); if (__first == __last) return __last; _ForwardIterator __dest = __first; ++__first; while (++__first != __last) if (!__binary_pred(__dest, __first)) *++__dest = std::move(*__first); return ++__dest; } # 872 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator unique(_ForwardIterator __first, _ForwardIterator __last) { ; return std::__unique(__first, __last, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 903 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred) { ; return std::__unique(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); } template _OutputIterator __unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, forward_iterator_tag, output_iterator_tag) { _ForwardIterator __next = __first; *__result = *__first; while (++__next != __last) if (!__binary_pred(__first, __next)) { __first = __next; *++__result = *__first; } return ++__result; } template _OutputIterator __unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, input_iterator_tag, output_iterator_tag) { typename iterator_traits<_InputIterator>::value_type __value = *__first; __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred)) __rebound_pred = __gnu_cxx::__ops::__iter_comp_val(__binary_pred); *__result = __value; while (++__first != __last) if (!__rebound_pred(__first, __value)) { __value = *__first; *++__result = __value; } return ++__result; } template _ForwardIterator __unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __binary_pred, input_iterator_tag, forward_iterator_tag) { *__result = *__first; while (++__first != __last) if (!__binary_pred(__result, __first)) *++__result = *__first; return ++__result; } template void __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) { while (true) if (__first == __last || __first == --__last) return; else { std::iter_swap(__first, __last); ++__first; } } template void __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) { if (__first == __last) return; --__last; while (__first < __last) { std::iter_swap(__first, __last); ++__first; --__last; } } # 1064 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; std::__reverse(__first, __last, std::__iterator_category(__first)); } # 1092 "/usr/include/c++/15/bits/stl_algo.h" 3 template _OutputIterator reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) { ; while (__first != __last) { --__last; *__result = *__last; ++__result; } return __result; } template _EuclideanRingElement __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) { while (__n != 0) { _EuclideanRingElement __t = __m % __n; __m = __n; __n = __t; } return __m; } inline namespace _V2 { template _ForwardIterator __rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, forward_iterator_tag) { if (__first == __middle) return __last; else if (__last == __middle) return __first; _ForwardIterator __first2 = __middle; do { std::iter_swap(__first, __first2); ++__first; ++__first2; if (__first == __middle) __middle = __first2; } while (__first2 != __last); _ForwardIterator __ret = __first; __first2 = __middle; while (__first2 != __last) { std::iter_swap(__first, __first2); ++__first; ++__first2; if (__first == __middle) __middle = __first2; else if (__first2 == __last) __first2 = __middle; } return __ret; } template _BidirectionalIterator __rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, bidirectional_iterator_tag) { if (__first == __middle) return __last; else if (__last == __middle) return __first; std::__reverse(__first, __middle, bidirectional_iterator_tag()); std::__reverse(__middle, __last, bidirectional_iterator_tag()); while (__first != __middle && __middle != __last) { std::iter_swap(__first, --__last); ++__first; } if (__first == __middle) { std::__reverse(__middle, __last, bidirectional_iterator_tag()); return __last; } else { std::__reverse(__first, __middle, bidirectional_iterator_tag()); return __first; } } template _RandomAccessIterator __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, random_access_iterator_tag) { if (__first == __middle) return __last; else if (__last == __middle) return __first; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename make_unsigned<_Distance>::type _UDistance; _Distance __n = __last - __first; _Distance __k = __middle - __first; if (__k == __n - __k) { std::swap_ranges(__first, __middle, __middle); return __middle; } _RandomAccessIterator __p = __first; _RandomAccessIterator __ret = __first + (__last - __middle); for (;;) { if (__k < __n - __k) { if (__is_pod(_ValueType) && __k == 1) { _ValueType __t = std::move(*__p); std::move(__p + 1, __p + __n, __p); *(__p + __n - 1) = std::move(__t); return __ret; } _RandomAccessIterator __q = __p + __k; for (_Distance __i = 0; __i < __n - __k; ++ __i) { std::iter_swap(__p, __q); ++__p; ++__q; } __n = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k); if (__n == 0) return __ret; std::swap(__n, __k); __k = __n - __k; } else { __k = __n - __k; if (__is_pod(_ValueType) && __k == 1) { _ValueType __t = std::move(*(__p + __n - 1)); std::move_backward(__p, __p + __n - 1, __p + __n); *__p = std::move(__t); return __ret; } _RandomAccessIterator __q = __p + __n; __p = __q - __k; for (_Distance __i = 0; __i < __n - __k; ++ __i) { --__p; --__q; std::iter_swap(__p, __q); } __n = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k); if (__n == 0) return __ret; std::swap(__n, __k); } } } # 1329 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _ForwardIterator rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) { ; ; return std::__rotate(__first, __middle, __last, std::__iterator_category(__first)); } } # 1367 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) { ; ; return std::copy(__first, __middle, std::copy(__middle, __last, __result)); } template _ForwardIterator __partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) { if (__first == __last) return __first; while (__pred(*__first)) if (++__first == __last) return __first; _ForwardIterator __next = __first; while (++__next != __last) if (__pred(*__next)) { std::iter_swap(__first, __next); ++__first; } return __first; } template _BidirectionalIterator __partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, bidirectional_iterator_tag) { while (true) { while (true) if (__first == __last) return __first; else if (__pred(*__first)) ++__first; else break; --__last; while (true) if (__first == __last) return __first; else if (!bool(__pred(*__last))) --__last; else break; std::iter_swap(__first, __last); ++__first; } } # 1448 "/usr/include/c++/15/bits/stl_algo.h" 3 template _ForwardIterator __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len, _Pointer __buffer, _Distance __buffer_size) { if (__len == 1) return __first; if (__len <= __buffer_size) { _ForwardIterator __result1 = __first; _Pointer __result2 = __buffer; *__result2 = std::move(*__first); ++__result2; ++__first; for (; __first != __last; ++__first) if (__pred(__first)) { *__result1 = std::move(*__first); ++__result1; } else { *__result2 = std::move(*__first); ++__result2; } std::move(__buffer, __result2, __result1); return __result1; } _ForwardIterator __middle = __first; std::advance(__middle, __len / 2); _ForwardIterator __left_split = std::__stable_partition_adaptive(__first, __middle, __pred, __len / 2, __buffer, __buffer_size); _Distance __right_len = __len - __len / 2; _ForwardIterator __right_split = std::__find_if_not_n(__middle, __right_len, __pred); if (__right_len) __right_split = std::__stable_partition_adaptive(__right_split, __last, __pred, __right_len, __buffer, __buffer_size); return std::rotate(__left_split, __middle, __right_split); } template _ForwardIterator __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { __first = std::__find_if_not(__first, __last, __pred); if (__first == __last) return __first; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; const _DistanceType __len = std::distance(__first, __last); # 1540 "/usr/include/c++/15/bits/stl_algo.h" 3 _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __len); return std::__stable_partition_adaptive(__first, __last, __pred, __len, __buf.begin(), _DistanceType(__buf.size())); } # 1566 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _ForwardIterator stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__stable_partition(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } template void __heap_select(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) { std::__make_heap(__first, __middle, __comp); for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) if (__comp(__i, __first)) std::__pop_heap(__first, __middle, __i, __comp); } template _RandomAccessIterator __partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) { typedef typename iterator_traits<_InputIterator>::value_type _InputValueType; typedef iterator_traits<_RandomAccessIterator> _RItTraits; typedef typename _RItTraits::difference_type _DistanceType; if (__result_first == __result_last) return __result_last; _RandomAccessIterator __result_real_last = __result_first; while (__first != __last && __result_real_last != __result_last) { *__result_real_last = *__first; ++__result_real_last; ++__first; } std::__make_heap(__result_first, __result_real_last, __comp); while (__first != __last) { if (__comp(__first, __result_first)) std::__adjust_heap(__result_first, _DistanceType(0), _DistanceType(__result_real_last - __result_first), _InputValueType(*__first), __comp); ++__first; } std::__sort_heap(__result_first, __result_real_last, __comp); return __result_real_last; } # 1660 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _RandomAccessIterator partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) { # 1675 "/usr/include/c++/15/bits/stl_algo.h" 3 ; ; ; return std::__partial_sort_copy(__first, __last, __result_first, __result_last, __gnu_cxx::__ops::__iter_less_iter()); } # 1710 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _RandomAccessIterator partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) { # 1727 "/usr/include/c++/15/bits/stl_algo.h" 3 ; ; ; return std::__partial_sort_copy(__first, __last, __result_first, __result_last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template void __unguarded_linear_insert(_RandomAccessIterator __last, _Compare __comp) { typename iterator_traits<_RandomAccessIterator>::value_type __val = std::move(*__last); _RandomAccessIterator __next = __last; --__next; while (__comp(__val, __next)) { *__last = std::move(*__next); __last = __next; --__next; } *__last = std::move(__val); } template void __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__first == __last) return; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) { if (__comp(__i, __first)) { typename iterator_traits<_RandomAccessIterator>::value_type __val = std::move(*__i); std::move_backward(__first, __i, __i + 1); *__first = std::move(__val); } else std::__unguarded_linear_insert(__i, __gnu_cxx::__ops::__val_comp_iter(__comp)); } } template inline void __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { for (_RandomAccessIterator __i = __first; __i != __last; ++__i) std::__unguarded_linear_insert(__i, __gnu_cxx::__ops::__val_comp_iter(__comp)); } enum { _S_threshold = 16 }; template void __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__last - __first > int(_S_threshold)) { std::__insertion_sort(__first, __first + int(_S_threshold), __comp); std::__unguarded_insertion_sort(__first + int(_S_threshold), __last, __comp); } else std::__insertion_sort(__first, __last, __comp); } template _RandomAccessIterator __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __pivot, _Compare __comp) { while (true) { while (__comp(__first, __pivot)) ++__first; --__last; while (__comp(__pivot, __last)) --__last; if (!(__first < __last)) return __first; std::iter_swap(__first, __last); ++__first; } } template inline _RandomAccessIterator __unguarded_partition_pivot(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { _RandomAccessIterator __mid = __first + (__last - __first) / 2; std::__move_median_to_first(__first, __first + 1, __mid, __last - 1, __comp); return std::__unguarded_partition(__first + 1, __last, __first, __comp); } template inline void __partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) { std::__heap_select(__first, __middle, __last, __comp); std::__sort_heap(__first, __middle, __comp); } template void __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp) { while (__last - __first > int(_S_threshold)) { if (__depth_limit == 0) { std::__partial_sort(__first, __last, __last, __comp); return; } --__depth_limit; _RandomAccessIterator __cut = std::__unguarded_partition_pivot(__first, __last, __comp); std::__introsort_loop(__cut, __last, __depth_limit, __comp); __last = __cut; } } template inline void __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__first != __last) { std::__introsort_loop(__first, __last, std::__lg(__last - __first) * 2, __comp); std::__final_insertion_sort(__first, __last, __comp); } } template void __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp) { while (__last - __first > 3) { if (__depth_limit == 0) { std::__heap_select(__first, __nth + 1, __last, __comp); std::iter_swap(__first, __nth); return; } --__depth_limit; _RandomAccessIterator __cut = std::__unguarded_partition_pivot(__first, __last, __comp); if (__cut <= __nth) __first = __cut; else __last = __cut; } std::__insertion_sort(__first, __last, __comp); } # 1961 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { ; return std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_comp_val(__comp)); } template _ForwardIterator __upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; _DistanceType __len = std::distance(__first, __last); while (__len > 0) { _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); if (__comp(__val, __middle)) __len = __half; else { __first = __middle; ++__first; __len = __len - __half - 1; } } return __first; } # 2017 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { ; return std::__upper_bound(__first, __last, __val, __gnu_cxx::__ops::__val_less_iter()); } # 2048 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { ; return std::__upper_bound(__first, __last, __val, __gnu_cxx::__ops::__val_comp_iter(__comp)); } template pair<_ForwardIterator, _ForwardIterator> __equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it) { typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; _DistanceType __len = std::distance(__first, __last); while (__len > 0) { _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); if (__comp_it_val(__middle, __val)) { __first = __middle; ++__first; __len = __len - __half - 1; } else if (__comp_val_it(__val, __middle)) __len = __half; else { _ForwardIterator __left = std::__lower_bound(__first, __middle, __val, __comp_it_val); std::advance(__first, __len); _ForwardIterator __right = std::__upper_bound(++__middle, __first, __val, __comp_val_it); return pair<_ForwardIterator, _ForwardIterator>(__left, __right); } } return pair<_ForwardIterator, _ForwardIterator>(__first, __first); } # 2121 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline pair<_ForwardIterator, _ForwardIterator> equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { ; ; return std::__equal_range(__first, __last, __val, __gnu_cxx::__ops::__iter_less_val(), __gnu_cxx::__ops::__val_less_iter()); } # 2158 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline pair<_ForwardIterator, _ForwardIterator> equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { ; ; return std::__equal_range(__first, __last, __val, __gnu_cxx::__ops::__iter_comp_val(__comp), __gnu_cxx::__ops::__val_comp_iter(__comp)); } # 2192 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] bool binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { ; ; _ForwardIterator __i = std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_less_val()); return __i != __last && !(__val < *__i); } # 2226 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] bool binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { ; ; _ForwardIterator __i = std::__lower_bound(__first, __last, __val, __gnu_cxx::__ops::__iter_comp_val(__comp)); return __i != __last && !bool(__comp(__val, *__i)); } template void __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first2, __first1)) { *__result = std::move(*__first2); ++__first2; } else { *__result = std::move(*__first1); ++__first1; } ++__result; } if (__first1 != __last1) std::move(__first1, __last1, __result); } template void __move_merge_adaptive_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result, _Compare __comp) { if (__first1 == __last1) { std::move_backward(__first2, __last2, __result); return; } else if (__first2 == __last2) return; --__last1; --__last2; while (true) { if (__comp(__last2, __last1)) { *--__result = std::move(*__last1); if (__first1 == __last1) { std::move_backward(__first2, ++__last2, __result); return; } --__last1; } else { *--__result = std::move(*__last2); if (__first2 == __last2) return; --__last2; } } } template _BidirectionalIterator1 __rotate_adaptive(_BidirectionalIterator1 __first, _BidirectionalIterator1 __middle, _BidirectionalIterator1 __last, _Distance __len1, _Distance __len2, _BidirectionalIterator2 __buffer, _Distance __buffer_size) { _BidirectionalIterator2 __buffer_end; if (__len1 > __len2 && __len2 <= __buffer_size) { if (__len2) { __buffer_end = std::move(__middle, __last, __buffer); std::move_backward(__first, __middle, __last); return std::move(__buffer, __buffer_end, __first); } else return __first; } else if (__len1 <= __buffer_size) { if (__len1) { __buffer_end = std::move(__first, __middle, __buffer); std::move(__middle, __last, __first); return std::move_backward(__buffer, __buffer_end, __last); } else return __last; } else return std::rotate(__first, __middle, __last); } template void __merge_adaptive(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Compare __comp) { if (__len1 <= __len2) { _Pointer __buffer_end = std::move(__first, __middle, __buffer); std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, __first, __comp); } else { _Pointer __buffer_end = std::move(__middle, __last, __buffer); std::__move_merge_adaptive_backward(__first, __middle, __buffer, __buffer_end, __last, __comp); } } template void __merge_adaptive_resize(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) { if (__len1 <= __buffer_size || __len2 <= __buffer_size) std::__merge_adaptive(__first, __middle, __last, __len1, __len2, __buffer, __comp); else { _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::__lower_bound(__middle, __last, *__first_cut, __gnu_cxx::__ops::__iter_comp_val(__comp)); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::__upper_bound(__first, __middle, *__second_cut, __gnu_cxx::__ops::__val_comp_iter(__comp)); __len11 = std::distance(__first, __first_cut); } _BidirectionalIterator __new_middle = std::__rotate_adaptive(__first_cut, __middle, __second_cut, _Distance(__len1 - __len11), __len22, __buffer, __buffer_size); std::__merge_adaptive_resize(__first, __first_cut, __new_middle, __len11, __len22, __buffer, __buffer_size, __comp); std::__merge_adaptive_resize(__new_middle, __second_cut, __last, _Distance(__len1 - __len11), _Distance(__len2 - __len22), __buffer, __buffer_size, __comp); } } template void __merge_without_buffer(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Compare __comp) { if (__len1 == 0 || __len2 == 0) return; if (__len1 + __len2 == 2) { if (__comp(__middle, __first)) std::iter_swap(__first, __middle); return; } _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::__lower_bound(__middle, __last, *__first_cut, __gnu_cxx::__ops::__iter_comp_val(__comp)); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::__upper_bound(__first, __middle, *__second_cut, __gnu_cxx::__ops::__val_comp_iter(__comp)); __len11 = std::distance(__first, __first_cut); } _BidirectionalIterator __new_middle = std::rotate(__first_cut, __middle, __second_cut); std::__merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22, __comp); std::__merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22, __comp); } template void __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { typedef typename iterator_traits<_BidirectionalIterator>::value_type _ValueType; typedef typename iterator_traits<_BidirectionalIterator>::difference_type _DistanceType; if (__first == __middle || __middle == __last) return; const _DistanceType __len1 = std::distance(__first, __middle); const _DistanceType __len2 = std::distance(__middle, __last); # 2510 "/usr/include/c++/15/bits/stl_algo.h" 3 typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf; _TmpBuf __buf(__first, std::min(__len1, __len2)); if (__builtin_expect(__buf.size() == __buf.requested_size(), true)) std::__merge_adaptive (__first, __middle, __last, __len1, __len2, __buf.begin(), __comp); else if (__builtin_expect(__buf.begin() == 0, false)) std::__merge_without_buffer (__first, __middle, __last, __len1, __len2, __comp); else std::__merge_adaptive_resize (__first, __middle, __last, __len1, __len2, __buf.begin(), _DistanceType(__buf.size()), __comp); } # 2549 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) { ; ; ; std::__inplace_merge(__first, __middle, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 2591 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { ; ; ; std::__inplace_merge(__first, __middle, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __move_merge(_InputIterator __first1, _InputIterator __last1, _InputIterator __first2, _InputIterator __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first2, __first1)) { *__result = std::move(*__first2); ++__first2; } else { *__result = std::move(*__first1); ++__first1; } ++__result; } return std::move(__first2, __last2, std::move(__first1, __last1, __result)) ; } template void __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator2 __result, _Distance __step_size, _Compare __comp) { const _Distance __two_step = 2 * __step_size; while (__last - __first >= __two_step) { __result = std::__move_merge(__first, __first + __step_size, __first + __step_size, __first + __two_step, __result, __comp); __first += __two_step; } __step_size = std::min(_Distance(__last - __first), __step_size); std::__move_merge(__first, __first + __step_size, __first + __step_size, __last, __result, __comp); } template void __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance __chunk_size, _Compare __comp) { while (__last - __first >= __chunk_size) { std::__insertion_sort(__first, __first + __chunk_size, __comp); __first += __chunk_size; } std::__insertion_sort(__first, __last, __comp); } enum { _S_chunk_size = 7 }; template void __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; const _Distance __len = __last - __first; const _Pointer __buffer_last = __buffer + __len; _Distance __step_size = _S_chunk_size; std::__chunk_insertion_sort(__first, __last, __step_size, __comp); while (__step_size < __len) { std::__merge_sort_loop(__first, __last, __buffer, __step_size, __comp); __step_size *= 2; std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp); __step_size *= 2; } } template void __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Pointer __buffer, _Compare __comp) { std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); std::__merge_adaptive(__first, __middle, __last, __middle - __first, __last - __middle, __buffer, __comp); } template void __stable_sort_adaptive_resize(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) { const _Distance __len = (__last - __first + 1) / 2; const _RandomAccessIterator __middle = __first + __len; if (__len > __buffer_size) { std::__stable_sort_adaptive_resize(__first, __middle, __buffer, __buffer_size, __comp); std::__stable_sort_adaptive_resize(__middle, __last, __buffer, __buffer_size, __comp); std::__merge_adaptive_resize(__first, __middle, __last, _Distance(__middle - __first), _Distance(__last - __middle), __buffer, __buffer_size, __comp); } else std::__stable_sort_adaptive(__first, __middle, __last, __buffer, __comp); } template void __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__last - __first < 15) { std::__insertion_sort(__first, __last, __comp); return; } _RandomAccessIterator __middle = __first + (__last - __first) / 2; std::__inplace_stable_sort(__first, __middle, __comp); std::__inplace_stable_sort(__middle, __last, __comp); std::__merge_without_buffer(__first, __middle, __last, __middle - __first, __last - __middle, __comp); } # 2779 "/usr/include/c++/15/bits/stl_algo.h" 3 template bool __includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first2, __first1)) return false; if (!__comp(__first1, __first2)) ++__first2; ++__first1; } return __first2 == __last2; } # 2817 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { ; ; ; ; return std::__includes(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_less_iter()); } # 2862 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) { ; ; ; ; return std::__includes(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 2898 "/usr/include/c++/15/bits/stl_algo.h" 3 template bool __next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (__comp(__i, __ii)) { _BidirectionalIterator __j = __last; while (!__comp(__i, --__j)) {} std::iter_swap(__i, __j); std::__reverse(__ii, __last, std::__iterator_category(__first)); return true; } if (__i == __first) { std::__reverse(__first, __last, std::__iterator_category(__first)); return false; } } } # 2948 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; ; return std::__next_permutation (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 2981 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { ; ; return std::__next_permutation (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template bool __prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (__comp(__ii, __i)) { _BidirectionalIterator __j = __last; while (!__comp(--__j, __i)) {} std::iter_swap(__i, __j); std::__reverse(__ii, __last, std::__iterator_category(__first)); return true; } if (__i == __first) { std::__reverse(__first, __last, std::__iterator_category(__first)); return false; } } } # 3051 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; ; return std::__prev_permutation(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3084 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { ; ; return std::__prev_permutation(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred, const _Tp& __new_value) { for (; __first != __last; ++__first, (void)++__result) if (__pred(__first)) *__result = __new_value; else *__result = *__first; return __result; } # 3136 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __old_value, const _Tp& __new_value) { ; return std::__replace_copy_if(__first, __last, __result, __gnu_cxx::__ops::__iter_equals_val(__old_value), __new_value); } # 3171 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred, const _Tp& __new_value) { ; return std::__replace_copy_if(__first, __last, __result, __gnu_cxx::__ops::__pred_iter(__pred), __new_value); } # 3200 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool is_sorted(_ForwardIterator __first, _ForwardIterator __last) { return std::is_sorted_until(__first, __last) == __last; } # 3215 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { return std::is_sorted_until(__first, __last, __comp) == __last; } template _ForwardIterator __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first == __last) return __last; _ForwardIterator __next = __first; for (++__next; __next != __last; __first = __next, (void)++__next) if (__comp(__next, __first)) return __next; return __next; } # 3246 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__is_sorted_until(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3271 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__is_sorted_until(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 3297 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline pair minmax(const _Tp& __a, const _Tp& __b) { return __b < __a ? pair(__b, __a) : pair(__a, __b); } # 3318 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline pair minmax(const _Tp& __a, const _Tp& __b, _Compare __comp) { return __comp(__b, __a) ? pair(__b, __a) : pair(__a, __b); } template constexpr pair<_ForwardIterator, _ForwardIterator> __minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { _ForwardIterator __next = __first; if (__first == __last || ++__next == __last) return std::make_pair(__first, __first); _ForwardIterator __min{}, __max{}; if (__comp(__next, __first)) { __min = __next; __max = __first; } else { __min = __first; __max = __next; } __first = __next; ++__first; while (__first != __last) { __next = __first; if (++__next == __last) { if (__comp(__first, __min)) __min = __first; else if (!__comp(__first, __max)) __max = __first; break; } if (__comp(__next, __first)) { if (__comp(__next, __min)) __min = __next; if (!__comp(__first, __max)) __max = __first; } else { if (__comp(__first, __min)) __min = __first; if (!__comp(__next, __max)) __max = __next; } __first = __next; ++__first; } return std::make_pair(__min, __max); } # 3398 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__minmax_element(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3426 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__minmax_element(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template [[__nodiscard__]] constexpr inline pair<_Tp, _Tp> minmax(initializer_list<_Tp> __l) { ; pair __p = std::__minmax_element(__l.begin(), __l.end(), __gnu_cxx::__ops::__iter_less_iter()); return std::make_pair(*__p.first, *__p.second); } template [[__nodiscard__]] constexpr inline pair<_Tp, _Tp> minmax(initializer_list<_Tp> __l, _Compare __comp) { ; pair __p = std::__minmax_element(__l.begin(), __l.end(), __gnu_cxx::__ops::__iter_comp_iter(__comp)); return std::make_pair(*__p.first, *__p.second); } # 3482 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred) { ; return std::__is_permutation(__first1, __last1, __first2, __gnu_cxx::__ops::__iter_comp_iter(__pred)); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" template bool __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { using _Cat1 = typename iterator_traits<_ForwardIterator1>::iterator_category; using _Cat2 = typename iterator_traits<_ForwardIterator2>::iterator_category; using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>; using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>; constexpr bool __ra_iters = __and_<_It1_is_RA, _It2_is_RA>::value; if constexpr (__ra_iters) { if ((__last1 - __first1) != (__last2 - __first2)) return false; } for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) if (!__pred(__first1, __first2)) break; if constexpr (__ra_iters) { if (__first1 == __last1) return true; } else { auto __d1 = std::distance(__first1, __last1); auto __d2 = std::distance(__first2, __last2); if (__d1 == 0 && __d2 == 0) return true; if (__d1 != __d2) return false; } for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) { if (__scan != std::__find_if(__first1, __scan, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) continue; auto __matches = std::__count_if(__first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); if (0 == __matches || std::__count_if(__scan, __last1, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) != __matches) return false; } return true; } #pragma GCC diagnostic pop # 3578 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { ; ; return std::__is_permutation(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 3606 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline bool is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { ; ; return std::__is_permutation(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred)); } # 3634 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[nodiscard]] constexpr const _Tp& clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi) { do { if (std::__is_constant_evaluated() && !bool(!(__hi < __lo))) std::__glibcxx_assert_fail(); } while (false); return std::min(std::max(__val, __lo), __hi); } # 3654 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[nodiscard]] constexpr const _Tp& clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp) { do { if (std::__is_constant_evaluated() && !bool(!__comp(__hi, __lo))) std::__glibcxx_assert_fail(); } while (false); return std::min(std::max(__val, __lo, __comp), __hi, __comp); } # 3684 "/usr/include/c++/15/bits/stl_algo.h" 3 template pair<_IntType, _IntType> __gen_two_uniform_ints(_IntType __b0, _IntType __b1, _UniformRandomBitGenerator&& __g) { _IntType __x = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g); return std::make_pair(__x / __b1, __x % __b1); } # 3706 "/usr/include/c++/15/bits/stl_algo.h" 3 template void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, _UniformRandomNumberGenerator&& __g) { ; if (__first == __last) return; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; typedef typename std::make_unsigned<_DistanceType>::type __ud_type; typedef typename std::uniform_int_distribution<__ud_type> __distr_type; typedef typename __distr_type::param_type __p_type; typedef typename remove_reference<_UniformRandomNumberGenerator>::type _Gen; typedef typename common_type::type __uc_type; const __uc_type __urngrange = __g.max() - __g.min(); const __uc_type __urange = __uc_type(__last - __first); if (__urngrange / __urange >= __urange) { _RandomAccessIterator __i = __first + 1; if ((__urange % 2) == 0) { __distr_type __d{0, 1}; std::iter_swap(__i++, __first + __d(__g)); } while (__i != __last) { const __uc_type __swap_range = __uc_type(__i - __first) + 1; const pair<__uc_type, __uc_type> __pospos = __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g); std::iter_swap(__i++, __first + __pospos.first); std::iter_swap(__i++, __first + __pospos.second); } return; } __distr_type __d; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first))); } # 3789 "/usr/include/c++/15/bits/stl_algo.h" 3 template _Function for_each(_InputIterator __first, _InputIterator __last, _Function __f) { ; for (; __first != __last; ++__first) __f(*__first); return __f; } # 3815 "/usr/include/c++/15/bits/stl_algo.h" 3 template _InputIterator for_each_n(_InputIterator __first, _Size __n, _Function __f) { auto __n2 = std::__size_to_integer(__n); using _Cat = typename iterator_traits<_InputIterator>::iterator_category; if constexpr (is_base_of_v) { if (__n2 <= 0) return __first; auto __last = __first + __n2; std::for_each(__first, __last, std::move(__f)); return __last; } else { while (__n2-->0) { __f(*__first); ++__first; } return __first; } } # 3851 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _InputIterator find(_InputIterator __first, _InputIterator __last, const _Tp& __val) { ; using _ValT = typename iterator_traits<_InputIterator>::value_type; if constexpr (__can_use_memchr_for_find<_ValT, _Tp>) if constexpr (is_pointer_v ) { if (!(static_cast<_ValT>(__val) == __val)) return __last; else if (!__is_constant_evaluated()) { const int __ival = static_cast(__val); if (auto __n = __last - __first; __n > 0) { const void* __p0 = std::__niter_base(__first); if (auto __p1 = __builtin_memchr(__p0, __ival, __n)) return __first + ((const char*)__p1 - (const char*)__p0); } return __last; } } return std::__find_if(__first, __last, __gnu_cxx::__ops::__iter_equals_val(__val)); } # 3909 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _InputIterator find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { ; return std::__find_if(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } # 3941 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] _InputIterator find_first_of(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2) { ; ; for (; __first1 != __last1; ++__first1) for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) if (*__first1 == *__iter) return __first1; return __last1; } # 3982 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] _InputIterator find_first_of(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, _BinaryPredicate __comp) { ; ; for (; __first1 != __last1; ++__first1) for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) if (__comp(*__first1, *__iter)) return __first1; return __last1; } # 4015 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator adjacent_find(_ForwardIterator __first, _ForwardIterator __last) { ; return std::__adjacent_find(__first, __last, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 4041 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred) { ; return std::__adjacent_find(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); } # 4067 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline typename iterator_traits<_InputIterator>::difference_type count(_InputIterator __first, _InputIterator __last, const _Tp& __value) { ; return std::__count_if(__first, __last, __gnu_cxx::__ops::__iter_equals_val(__value)); } # 4091 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline typename iterator_traits<_InputIterator>::difference_type count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { ; return std::__count_if(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } # 4132 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { ; ; return std::__search(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 4166 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Integer __count, const _Tp& __val) { ; return std::__search_n(__first, __last, __count, __gnu_cxx::__ops::__iter_equals_val(__val)); } # 4200 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Integer __count, const _Tp& __val, _BinaryPredicate __binary_pred) { ; return std::__search_n(__first, __last, __count, __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val)); } # 4226 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] inline _ForwardIterator search(_ForwardIterator __first, _ForwardIterator __last, const _Searcher& __searcher) { return __searcher(__first, __last).first; } # 4250 "/usr/include/c++/15/bits/stl_algo.h" 3 template _OutputIterator transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __unary_op) { ; for (; __first != __last; ++__first, (void)++__result) *__result = __unary_op(*__first); return __result; } # 4288 "/usr/include/c++/15/bits/stl_algo.h" 3 template _OutputIterator transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _OutputIterator __result, _BinaryOperation __binary_op) { ; for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result) *__result = __binary_op(*__first1, *__first2); return __result; } # 4322 "/usr/include/c++/15/bits/stl_algo.h" 3 template void replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) { ; for (; __first != __last; ++__first) if (*__first == __old_value) *__first = __new_value; } # 4355 "/usr/include/c++/15/bits/stl_algo.h" 3 template void replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) { ; for (; __first != __last; ++__first) if (__pred(*__first)) *__first = __new_value; } # 4387 "/usr/include/c++/15/bits/stl_algo.h" 3 template void generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) { ; for (; __first != __last; ++__first) *__first = __gen(); } # 4420 "/usr/include/c++/15/bits/stl_algo.h" 3 template _OutputIterator generate_n(_OutputIterator __first, _Size __n, _Generator __gen) { typedef __decltype(std::__size_to_integer(__n)) _IntSize; for (_IntSize __niter = std::__size_to_integer(__n); __niter > 0; --__niter, (void) ++__first) *__first = __gen(); return __first; } # 4455 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { ; if (__first == __last) return __result; return std::__unique_copy(__first, __last, __result, __gnu_cxx::__ops::__iter_equal_to_iter(), std::__iterator_category(__first), std::__iterator_category(__result)); } # 4495 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred) { ; if (__first == __last) return __result; return std::__unique_copy(__first, __last, __result, __gnu_cxx::__ops::__iter_comp_iter(__binary_pred), std::__iterator_category(__first), std::__iterator_category(__result)); } # 4534 "/usr/include/c++/15/bits/stl_algo.h" 3 template __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) inline void random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; if (__first == __last) return; # 4569 "/usr/include/c++/15/bits/stl_algo.h" 3 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) { _RandomAccessIterator __j = __first + (std::rand() % ((__i - __first) + 1)); if (__i != __j) std::iter_swap(__i, __j); } } # 4597 "/usr/include/c++/15/bits/stl_algo.h" 3 template __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) void random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomNumberGenerator&& __rand) { ; if (__first == __last) return; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) { _RandomAccessIterator __j = __first + __rand((__i - __first) + 1); if (__i != __j) std::iter_swap(__i, __j); } } # 4639 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _ForwardIterator partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__partition(__first, __last, __pred, std::__iterator_category(__first)); } # 4674 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) { ; ; ; std::__partial_sort(__first, __middle, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 4713 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) { ; ; ; std::__partial_sort(__first, __middle, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 4750 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) { ; ; ; if (__first == __last || __nth == __last) return; std::__introselect(__first, __nth, __last, std::__lg(__last - __first) * 2, __gnu_cxx::__ops::__iter_less_iter()); } # 4790 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) { ; ; ; if (__first == __last || __nth == __last) return; std::__introselect(__first, __nth, __last, std::__lg(__last - __first) * 2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 4828 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 4859 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __merge(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first2, __first1)) { *__result = *__first2; ++__first2; } else { *__result = *__first1; ++__first1; } ++__result; } return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } # 4922 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator merge(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__merge(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 4973 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator merge(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__merge(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template inline void __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; if (__first == __last) return; # 5022 "/usr/include/c++/15/bits/stl_algo.h" 3 typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; _TmpBuf __buf(__first, (__last - __first + 1) / 2); if (__builtin_expect(__buf.requested_size() == __buf.size(), true)) std::__stable_sort_adaptive(__first, __first + _DistanceType(__buf.size()), __last, __buf.begin(), __comp); else if (__builtin_expect(__buf.begin() == 0, false)) std::__inplace_stable_sort(__first, __last, __comp); else std::__stable_sort_adaptive_resize(__first, __last, __buf.begin(), _DistanceType(__buf.size()), __comp); } # 5058 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; std::__stable_sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 5093 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; std::__stable_sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first1, __first2)) { *__result = *__first1; ++__first1; } else if (__comp(__first2, __first1)) { *__result = *__first2; ++__first2; } else { *__result = *__first1; ++__first1; ++__first2; } ++__result; } return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } # 5164 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_union(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5215 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_union(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first1, __first2)) ++__first1; else if (__comp(__first2, __first1)) ++__first2; else { *__result = *__first1; ++__first1; ++__first2; ++__result; } return __result; } # 5288 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_intersection(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5338 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_intersection(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first1, __first2)) { *__result = *__first1; ++__first1; ++__result; } else if (__comp(__first2, __first1)) ++__first2; else { ++__first1; ++__first2; } return std::copy(__first1, __last1, __result); } # 5413 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5465 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first1, __first2)) { *__result = *__first1; ++__first1; ++__result; } else if (__comp(__first2, __first1)) { *__result = *__first2; ++__first2; ++__result; } else { ++__first1; ++__first2; } return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } # 5546 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5598 "/usr/include/c++/15/bits/stl_algo.h" 3 template inline _OutputIterator set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _ForwardIterator __min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (__comp(__first, __result)) __result = __first; return __result; } # 5652 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr _ForwardIterator inline min_element(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__min_element(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 5677 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__min_element(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _ForwardIterator __max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (__comp(__result, __first)) __result = __first; return __result; } # 5716 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__max_element(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 5741 "/usr/include/c++/15/bits/stl_algo.h" 3 template [[__nodiscard__]] constexpr inline _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__max_element(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr inline _Tp min(initializer_list<_Tp> __l) { ; return *std::__min_element(__l.begin(), __l.end(), __gnu_cxx::__ops::__iter_less_iter()); } template constexpr inline _Tp min(initializer_list<_Tp> __l, _Compare __comp) { ; return *std::__min_element(__l.begin(), __l.end(), __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr inline _Tp max(initializer_list<_Tp> __l) { ; return *std::__max_element(__l.begin(), __l.end(), __gnu_cxx::__ops::__iter_less_iter()); } template constexpr inline _Tp max(initializer_list<_Tp> __l, _Compare __comp) { ; return *std::__max_element(__l.begin(), __l.end(), __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _RandomAccessIterator __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag, _RandomAccessIterator __out, random_access_iterator_tag, _Size __n, _UniformRandomBitGenerator&& __g) { using __distrib_type = uniform_int_distribution<_Size>; using __param_type = typename __distrib_type::param_type; __distrib_type __d{}; _Size __sample_sz = 0; while (__first != __last && __sample_sz != __n) { __out[__sample_sz++] = *__first; ++__first; } for (auto __pop_sz = __sample_sz; __first != __last; ++__first, (void) ++__pop_sz) { const auto __k = __d(__g, __param_type{0, __pop_sz}); if (__k < __n) __out[__k] = *__first; } return __out + __sample_sz; } template _OutputIterator __sample(_ForwardIterator __first, _ForwardIterator __last, forward_iterator_tag, _OutputIterator __out, _Cat, _Size __n, _UniformRandomBitGenerator&& __g) { using __distrib_type = uniform_int_distribution<_Size>; using __param_type = typename __distrib_type::param_type; using _USize = make_unsigned_t<_Size>; using _Gen = remove_reference_t<_UniformRandomBitGenerator>; using __uc_type = common_type_t; if (__first == __last) return __out; __distrib_type __d{}; _Size __unsampled_sz = std::distance(__first, __last); __n = std::min(__n, __unsampled_sz); const __uc_type __urngrange = __g.max() - __g.min(); if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz)) { while (__n != 0 && __unsampled_sz >= 2) { const pair<_Size, _Size> __p = __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g); --__unsampled_sz; if (__p.first < __n) { *__out++ = *__first; --__n; } ++__first; if (__n == 0) break; --__unsampled_sz; if (__p.second < __n) { *__out++ = *__first; --__n; } ++__first; } } for (; __n != 0; ++__first) if (__d(__g, __param_type{0, --__unsampled_sz}) < __n) { *__out++ = *__first; --__n; } return __out; } template _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last, _SampleIterator __out, _Distance __n, _UniformRandomBitGenerator&& __g) { using __pop_cat = typename std::iterator_traits<_PopulationIterator>::iterator_category; using __samp_cat = typename std::iterator_traits<_SampleIterator>::iterator_category; static_assert( __or_, is_convertible<__samp_cat, random_access_iterator_tag>>::value, "output range must use a RandomAccessIterator when input range" " does not meet the ForwardIterator requirements"); static_assert(is_integral<_Distance>::value, "sample size must be an integer type"); typename iterator_traits<_PopulationIterator>::difference_type __d = __n; return std:: __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d, std::forward<_UniformRandomBitGenerator>(__g)); } } #pragma GCC diagnostic pop # 64 "/usr/include/c++/15/algorithm" 2 3 # 80 "/usr/include/c++/15/algorithm" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 81 "/usr/include/c++/15/algorithm" 2 3 # 89 "/usr/include/c++/15/algorithm" 3 # 1 "/usr/include/c++/15/pstl/glue_algorithm_defs.h" 1 3 # 18 "/usr/include/c++/15/pstl/glue_algorithm_defs.h" 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::difference_type> count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::difference_type> count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _UnaryOperation __op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator __result, _BinaryOperation __op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, const _Tp& __old_value, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _ForwardIterator __d_first); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __p); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __d_first); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); } # 90 "/usr/include/c++/15/algorithm" 2 3 # 4 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" 2 # 1 "/usr/include/c++/15/cstring" 1 3 # 47 "/usr/include/c++/15/cstring" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 48 "/usr/include/c++/15/cstring" 2 3 # 1 "/usr/include/string.h" 1 3 4 # 26 "/usr/include/string.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/string.h" 2 3 4 extern "C" { # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 34 "/usr/include/string.h" 2 3 4 # 43 "/usr/include/string.h" 3 4 extern void *memcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern void *memmove (void *__dest, const void *__src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern void *memccpy (void *__restrict __dest, const void *__restrict __src, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); extern int memcmp (const void *__s1, const void *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); # 80 "/usr/include/string.h" 3 4 extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern "C++" { extern void *memchr (void *__s, int __c, size_t __n) noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const void *memchr (const void *__s, int __c, size_t __n) noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void * memchr (void *__s, int __c, size_t __n) noexcept (true) { return __builtin_memchr (__s, __c, __n); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void * memchr (const void *__s, int __c, size_t __n) noexcept (true) { return __builtin_memchr (__s, __c, __n); } } # 115 "/usr/include/string.h" 3 4 extern "C++" void *rawmemchr (void *__s, int __c) noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" const void *rawmemchr (const void *__s, int __c) noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" void *memrchr (void *__s, int __c, size_t __n) noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 3))); extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 3))); # 141 "/usr/include/string.h" 3 4 extern char *strcpy (char *__restrict __dest, const char *__restrict __src) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *strncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *strcat (char *__restrict __dest, const char *__restrict __src) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *strncat (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern int strcmp (const char *__s1, const char *__s2) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strncmp (const char *__s1, const char *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strcoll (const char *__s1, const char *__s2) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern size_t strxfrm (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__access__ (__write_only__, 1, 3))); extern char *strdup (const char *__s) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); extern char *strndup (const char *__string, size_t __n) noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); # 224 "/usr/include/string.h" 3 4 extern "C++" { extern char *strchr (char *__s, int __c) noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *strchr (const char *__s, int __c) noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * strchr (char *__s, int __c) noexcept (true) { return __builtin_strchr (__s, __c); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * strchr (const char *__s, int __c) noexcept (true) { return __builtin_strchr (__s, __c); } } extern "C++" { extern char *strrchr (char *__s, int __c) noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *strrchr (const char *__s, int __c) noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * strrchr (char *__s, int __c) noexcept (true) { return __builtin_strrchr (__s, __c); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * strrchr (const char *__s, int __c) noexcept (true) { return __builtin_strrchr (__s, __c); } } # 281 "/usr/include/string.h" 3 4 extern "C++" char *strchrnul (char *__s, int __c) noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" const char *strchrnul (const char *__s, int __c) noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 293 "/usr/include/string.h" 3 4 extern size_t strcspn (const char *__s, const char *__reject) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern size_t strspn (const char *__s, const char *__accept) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern "C++" { extern char *strpbrk (char *__s, const char *__accept) noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern const char *strpbrk (const char *__s, const char *__accept) noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * strpbrk (char *__s, const char *__accept) noexcept (true) { return __builtin_strpbrk (__s, __accept); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * strpbrk (const char *__s, const char *__accept) noexcept (true) { return __builtin_strpbrk (__s, __accept); } } extern "C++" { extern char *strstr (char *__haystack, const char *__needle) noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern const char *strstr (const char *__haystack, const char *__needle) noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * strstr (char *__haystack, const char *__needle) noexcept (true) { return __builtin_strstr (__haystack, __needle); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * strstr (const char *__haystack, const char *__needle) noexcept (true) { return __builtin_strstr (__haystack, __needle); } } extern char *strtok (char *__restrict __s, const char *__restrict __delim) noexcept (true) __attribute__ ((__nonnull__ (2))); extern char *__strtok_r (char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr) noexcept (true) __attribute__ ((__nonnull__ (2, 3))); extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr) noexcept (true) __attribute__ ((__nonnull__ (2, 3))); extern "C++" char *strcasestr (char *__haystack, const char *__needle) noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern "C++" const char *strcasestr (const char *__haystack, const char *__needle) noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); # 389 "/usr/include/string.h" 3 4 extern void *memmem (const void *__haystack, size_t __haystacklen, const void *__needle, size_t __needlelen) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__access__ (__read_only__, 1, 2))) __attribute__ ((__access__ (__read_only__, 3, 4))); extern void *__mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern void *mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern size_t strlen (const char *__s) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern size_t strnlen (const char *__string, size_t __maxlen) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern char *strerror (int __errnum) noexcept (true); # 444 "/usr/include/string.h" 3 4 extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 2, 3))); extern const char *strerrordesc_np (int __err) noexcept (true); extern const char *strerrorname_np (int __err) noexcept (true); extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); # 1 "/usr/include/strings.h" 1 3 4 # 23 "/usr/include/strings.h" 3 4 # 1 "/usr/lib/gcc/riscv64-linux-gnu/15/include/stddef.h" 1 3 4 # 24 "/usr/include/strings.h" 2 3 4 extern "C" { extern int bcmp (const void *__s1, const void *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern void bcopy (const void *__src, void *__dest, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); extern "C++" { extern char *index (char *__s, int __c) noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *index (const char *__s, int __c) noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * index (char *__s, int __c) noexcept (true) { return __builtin_index (__s, __c); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * index (const char *__s, int __c) noexcept (true) { return __builtin_index (__s, __c); } } extern "C++" { extern char *rindex (char *__s, int __c) noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *rindex (const char *__s, int __c) noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * rindex (char *__s, int __c) noexcept (true) { return __builtin_rindex (__s, __c); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * rindex (const char *__s, int __c) noexcept (true) { return __builtin_rindex (__s, __c); } } # 104 "/usr/include/strings.h" 3 4 extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); __extension__ extern int ffsll (long long int __ll) noexcept (true) __attribute__ ((__const__)); extern int strcasecmp (const char *__s1, const char *__s2) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); extern int strncasecmp_l (const char *__s1, const char *__s2, size_t __n, locale_t __loc) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); } # 1 "/usr/include/riscv64-linux-gnu/bits/strings_fortified.h" 1 3 4 # 22 "/usr/include/riscv64-linux-gnu/bits/strings_fortified.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void __attribute__ ((__leaf__)) bcopy (const void *__src, void *__dest, size_t __len) noexcept (true) { (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_dynamic_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void __attribute__ ((__leaf__)) bzero (void *__dest, size_t __len) noexcept (true) { (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_dynamic_object_size (__dest, 0)); } # 145 "/usr/include/strings.h" 2 3 4 # 463 "/usr/include/string.h" 2 3 4 extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) ; extern char *strsep (char **__restrict __stringp, const char *__restrict __delim) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *strsignal (int __sig) noexcept (true); extern const char *sigabbrev_np (int __sig) noexcept (true); extern const char *sigdescr_np (int __sig) noexcept (true); extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *__stpncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern char *stpncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); extern size_t strlcpy (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); extern size_t strlcat (char *__restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); extern int strverscmp (const char *__s1, const char *__s2) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_write__, 1, 2))); extern "C++" char *basename (char *__filename) noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); extern "C++" const char *basename (const char *__filename) noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); # 548 "/usr/include/string.h" 3 4 # 1 "/usr/include/riscv64-linux-gnu/bits/string_fortified.h" 1 3 4 # 25 "/usr/include/riscv64-linux-gnu/bits/string_fortified.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) noexcept (true) { return __builtin___memcpy_chk (__dest, __src, __len, __builtin_dynamic_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__leaf__)) memmove (void *__dest, const void *__src, size_t __len) noexcept (true) { return __builtin___memmove_chk (__dest, __src, __len, __builtin_dynamic_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) noexcept (true) { return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_dynamic_object_size (__dest, 0)); } # 56 "/usr/include/riscv64-linux-gnu/bits/string_fortified.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void * __attribute__ ((__leaf__)) memset (void *__dest, int __ch, size_t __len) noexcept (true) { return __builtin___memset_chk (__dest, __ch, __len, __builtin_dynamic_object_size (__dest, 0)); } void __explicit_bzero_chk (void *__dest, size_t __len, size_t __destlen) noexcept (true) __attribute__ ((__nonnull__ (1))) ; extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void __attribute__ ((__leaf__)) explicit_bzero (void *__dest, size_t __len) noexcept (true) { __explicit_bzero_chk (__dest, __len, __builtin_dynamic_object_size (__dest, 0)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__leaf__)) strcpy (char * __restrict __dest, const char *__restrict __src) noexcept (true) { return __builtin___strcpy_chk (__dest, __src, __builtin_dynamic_object_size (__dest, 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__leaf__)) stpcpy (char * __restrict __dest, const char *__restrict __src) noexcept (true) { return __builtin___stpcpy_chk (__dest, __src, __builtin_dynamic_object_size (__dest, 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__leaf__)) strncpy (char * __restrict __dest, const char *__restrict __src, size_t __len) noexcept (true) { return __builtin___strncpy_chk (__dest, __src, __len, __builtin_dynamic_object_size (__dest, 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__leaf__)) stpncpy (char * __dest, const char *__src, size_t __n) noexcept (true) { return __builtin___stpncpy_chk (__dest, __src, __n, __builtin_dynamic_object_size (__dest, 1)); } # 135 "/usr/include/riscv64-linux-gnu/bits/string_fortified.h" 3 4 extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__leaf__)) strcat (char * __restrict __dest, const char *__restrict __src) noexcept (true) { return __builtin___strcat_chk (__dest, __src, __builtin_dynamic_object_size (__dest, 1)); } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char * __attribute__ ((__leaf__)) strncat (char * __restrict __dest, const char *__restrict __src, size_t __len) noexcept (true) { return __builtin___strncat_chk (__dest, __src, __len, __builtin_dynamic_object_size (__dest, 1)); } extern size_t __strlcpy_chk (char *__dest, const char *__src, size_t __n, size_t __destlen) noexcept (true); extern size_t __strlcpy_alias (char *__dest, const char *__src, size_t __n) noexcept (true) __asm__ ("" "strlcpy") ; extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) strlcpy (char * __restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) { if (__builtin_dynamic_object_size (__dest, 1) != (size_t) -1 && (!__builtin_constant_p (__n > __builtin_dynamic_object_size (__dest, 1)) || __n > __builtin_dynamic_object_size (__dest, 1))) return __strlcpy_chk (__dest, __src, __n, __builtin_dynamic_object_size (__dest, 1)); return __strlcpy_alias (__dest, __src, __n); } extern size_t __strlcat_chk (char *__dest, const char *__src, size_t __n, size_t __destlen) noexcept (true); extern size_t __strlcat_alias (char *__dest, const char *__src, size_t __n) noexcept (true) __asm__ ("" "strlcat") ; extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) strlcat (char * __restrict __dest, const char *__restrict __src, size_t __n) noexcept (true) { if (__builtin_dynamic_object_size (__dest, 1) != (size_t) -1 && (!__builtin_constant_p (__n > __builtin_dynamic_object_size (__dest, 1)) || __n > __builtin_dynamic_object_size (__dest, 1))) return __strlcat_chk (__dest, __src, __n, __builtin_dynamic_object_size (__dest, 1)); return __strlcat_alias (__dest, __src, __n); } # 549 "/usr/include/string.h" 2 3 4 } # 49 "/usr/include/c++/15/cstring" 2 3 # 74 "/usr/include/c++/15/cstring" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::memchr; using ::memcmp; using ::memcpy; using ::memmove; using ::memset; using ::strcat; using ::strcmp; using ::strcoll; using ::strcpy; using ::strcspn; using ::strerror; using ::strlen; using ::strncat; using ::strncmp; using ::strncpy; using ::strspn; using ::strtok; using ::strxfrm; using ::strchr; using ::strpbrk; using ::strrchr; using ::strstr; # 127 "/usr/include/c++/15/cstring" 3 } } # 6 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" 2 # 1 "/usr/include/c++/15/iterator" 1 3 # 67 "/usr/include/c++/15/iterator" 3 # 1 "/usr/include/c++/15/bits/stream_iterator.h" 1 3 # 42 "/usr/include/c++/15/bits/stream_iterator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 52 "/usr/include/c++/15/bits/stream_iterator.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template, typename _Dist = ptrdiff_t> class istream_iterator : public iterator { public: typedef _CharT char_type; typedef _Traits traits_type; typedef basic_istream<_CharT, _Traits> istream_type; private: istream_type* _M_stream; _Tp _M_value; bool _M_ok; public: constexpr istream_iterator() noexcept(is_nothrow_default_constructible<_Tp>::value) : _M_stream(0), _M_value(), _M_ok(false) {} istream_iterator(istream_type& __s) : _M_stream(std::__addressof(__s)), _M_ok(true) { _M_read(); } constexpr istream_iterator(const istream_iterator& __obj) noexcept(is_nothrow_copy_constructible<_Tp>::value) : _M_stream(__obj._M_stream), _M_value(__obj._M_value), _M_ok(__obj._M_ok) { } # 100 "/usr/include/c++/15/bits/stream_iterator.h" 3 istream_iterator& operator=(const istream_iterator&) = default; ~istream_iterator() = default; [[__nodiscard__]] const _Tp& operator*() const noexcept { ; return _M_value; } [[__nodiscard__]] const _Tp* operator->() const noexcept { return std::__addressof((operator*())); } istream_iterator& operator++() { ; _M_read(); return *this; } istream_iterator operator++(int) { ; istream_iterator __tmp = *this; _M_read(); return __tmp; } private: bool _M_equal(const istream_iterator& __x) const noexcept { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } void _M_read() { if (_M_stream && !(*_M_stream >> _M_value)) { _M_stream = 0; _M_ok = false; } } [[__nodiscard__]] friend bool operator==(const istream_iterator& __x, const istream_iterator& __y) noexcept { return __x._M_equal(__y); } [[__nodiscard__]] friend bool operator!=(const istream_iterator& __x, const istream_iterator& __y) noexcept { return !__x._M_equal(__y); } # 183 "/usr/include/c++/15/bits/stream_iterator.h" 3 }; # 196 "/usr/include/c++/15/bits/stream_iterator.h" 3 template > class ostream_iterator : public iterator { public: typedef _CharT char_type; typedef _Traits traits_type; typedef basic_ostream<_CharT, _Traits> ostream_type; private: ostream_type* _M_stream; const _CharT* _M_string; public: ostream_iterator(ostream_type& __s) noexcept : _M_stream(std::__addressof(__s)), _M_string(0) {} # 231 "/usr/include/c++/15/bits/stream_iterator.h" 3 ostream_iterator(ostream_type& __s, const _CharT* __c) noexcept : _M_stream(std::__addressof(__s)), _M_string(__c) { } ostream_iterator(const ostream_iterator& __obj) noexcept : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } ostream_iterator& operator=(const ostream_iterator&) = default; ostream_iterator& operator=(const _Tp& __value) { ; *_M_stream << __value; if (_M_string) *_M_stream << _M_string; return *this; } [[__nodiscard__]] ostream_iterator& operator*() noexcept { return *this; } ostream_iterator& operator++() noexcept { return *this; } ostream_iterator& operator++(int) noexcept { return *this; } }; #pragma GCC diagnostic pop } # 68 "/usr/include/c++/15/iterator" 2 3 # 80 "/usr/include/c++/15/iterator" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 81 "/usr/include/c++/15/iterator" 2 3 # 8 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" 2 # 1 "/usr/include/c++/15/limits" 1 3 # 44 "/usr/include/c++/15/limits" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" #pragma GCC diagnostic ignored "-Wlong-long" #pragma GCC diagnostic ignored "-Wc++23-extensions" # 165 "/usr/include/c++/15/limits" 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum float_round_style { round_indeterminate = -1, round_toward_zero = 0, round_to_nearest = 1, round_toward_infinity = 2, round_toward_neg_infinity = 3 }; enum float_denorm_style { denorm_indeterminate = -1, denorm_absent = 0, denorm_present = 1 }; # 209 "/usr/include/c++/15/limits" 3 struct __numeric_limits_base { static constexpr bool is_specialized = false; static constexpr int digits = 0; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; # 295 "/usr/include/c++/15/limits" 3 static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 318 "/usr/include/c++/15/limits" 3 template struct numeric_limits : public __numeric_limits_base { static constexpr _Tp min() noexcept { return _Tp(); } static constexpr _Tp max() noexcept { return _Tp(); } static constexpr _Tp lowest() noexcept { return _Tp(); } static constexpr _Tp epsilon() noexcept { return _Tp(); } static constexpr _Tp round_error() noexcept { return _Tp(); } static constexpr _Tp infinity() noexcept { return _Tp(); } static constexpr _Tp quiet_NaN() noexcept { return _Tp(); } static constexpr _Tp signaling_NaN() noexcept { return _Tp(); } static constexpr _Tp denorm_min() noexcept { return _Tp(); } }; template struct numeric_limits : public numeric_limits<_Tp> { }; template struct numeric_limits : public numeric_limits<_Tp> { }; template struct numeric_limits : public numeric_limits<_Tp> { }; # 390 "/usr/include/c++/15/limits" 3 template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr bool min() noexcept { return false; } static constexpr bool max() noexcept { return true; } static constexpr bool lowest() noexcept { return min(); } static constexpr int digits = 1; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr bool epsilon() noexcept { return false; } static constexpr bool round_error() noexcept { return false; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr bool infinity() noexcept { return false; } static constexpr bool quiet_NaN() noexcept { return false; } static constexpr bool signaling_NaN() noexcept { return false; } static constexpr bool denorm_min() noexcept { return false; } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } static constexpr char max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } static constexpr char lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char epsilon() noexcept { return 0; } static constexpr char round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char infinity() noexcept { return char(); } static constexpr char quiet_NaN() noexcept { return char(); } static constexpr char signaling_NaN() noexcept { return char(); } static constexpr char denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr signed char min() noexcept { return -0x7f - 1; } static constexpr signed char max() noexcept { return 0x7f; } static constexpr signed char lowest() noexcept { return min(); } static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); static constexpr int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr signed char epsilon() noexcept { return 0; } static constexpr signed char round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr signed char infinity() noexcept { return static_cast(0); } static constexpr signed char quiet_NaN() noexcept { return static_cast(0); } static constexpr signed char signaling_NaN() noexcept { return static_cast(0); } static constexpr signed char denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned char min() noexcept { return 0; } static constexpr unsigned char max() noexcept { return 0x7f * 2U + 1; } static constexpr unsigned char lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned char epsilon() noexcept { return 0; } static constexpr unsigned char round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned char infinity() noexcept { return static_cast(0); } static constexpr unsigned char quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned char signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned char denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr wchar_t min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } static constexpr wchar_t max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } static constexpr wchar_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((wchar_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr wchar_t epsilon() noexcept { return 0; } static constexpr wchar_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr wchar_t infinity() noexcept { return wchar_t(); } static constexpr wchar_t quiet_NaN() noexcept { return wchar_t(); } static constexpr wchar_t signaling_NaN() noexcept { return wchar_t(); } static constexpr wchar_t denorm_min() noexcept { return wchar_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 803 "/usr/include/c++/15/limits" 3 template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char16_t min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } static constexpr char16_t max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } static constexpr char16_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char16_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char16_t epsilon() noexcept { return 0; } static constexpr char16_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char16_t infinity() noexcept { return char16_t(); } static constexpr char16_t quiet_NaN() noexcept { return char16_t(); } static constexpr char16_t signaling_NaN() noexcept { return char16_t(); } static constexpr char16_t denorm_min() noexcept { return char16_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char32_t min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } static constexpr char32_t max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } static constexpr char32_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char32_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char32_t epsilon() noexcept { return 0; } static constexpr char32_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char32_t infinity() noexcept { return char32_t(); } static constexpr char32_t quiet_NaN() noexcept { return char32_t(); } static constexpr char32_t signaling_NaN() noexcept { return char32_t(); } static constexpr char32_t denorm_min() noexcept { return char32_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr short min() noexcept { return -0x7fff - 1; } static constexpr short max() noexcept { return 0x7fff; } static constexpr short lowest() noexcept { return min(); } static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr short epsilon() noexcept { return 0; } static constexpr short round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr short infinity() noexcept { return short(); } static constexpr short quiet_NaN() noexcept { return short(); } static constexpr short signaling_NaN() noexcept { return short(); } static constexpr short denorm_min() noexcept { return short(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned short min() noexcept { return 0; } static constexpr unsigned short max() noexcept { return 0x7fff * 2U + 1; } static constexpr unsigned short lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned short epsilon() noexcept { return 0; } static constexpr unsigned short round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned short infinity() noexcept { return static_cast(0); } static constexpr unsigned short quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned short signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned short denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr int min() noexcept { return -0x7fffffff - 1; } static constexpr int max() noexcept { return 0x7fffffff; } static constexpr int lowest() noexcept { return min(); } static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr int epsilon() noexcept { return 0; } static constexpr int round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr int infinity() noexcept { return static_cast(0); } static constexpr int quiet_NaN() noexcept { return static_cast(0); } static constexpr int signaling_NaN() noexcept { return static_cast(0); } static constexpr int denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned int min() noexcept { return 0; } static constexpr unsigned int max() noexcept { return 0x7fffffff * 2U + 1; } static constexpr unsigned int lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned int epsilon() noexcept { return 0; } static constexpr unsigned int round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned int infinity() noexcept { return static_cast(0); } static constexpr unsigned int quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned int signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned int denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr long min() noexcept { return -0x7fffffffffffffffL - 1; } static constexpr long max() noexcept { return 0x7fffffffffffffffL; } static constexpr long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr long epsilon() noexcept { return 0; } static constexpr long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr long infinity() noexcept { return static_cast(0); } static constexpr long quiet_NaN() noexcept { return static_cast(0); } static constexpr long signaling_NaN() noexcept { return static_cast(0); } static constexpr long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned long min() noexcept { return 0; } static constexpr unsigned long max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } static constexpr unsigned long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned long epsilon() noexcept { return 0; } static constexpr unsigned long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned long infinity() noexcept { return static_cast(0); } static constexpr unsigned long quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned long signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr long long min() noexcept { return -0x7fffffffffffffffLL - 1; } static constexpr long long max() noexcept { return 0x7fffffffffffffffLL; } static constexpr long long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0)); static constexpr int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr long long epsilon() noexcept { return 0; } static constexpr long long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr long long infinity() noexcept { return static_cast(0); } static constexpr long long quiet_NaN() noexcept { return static_cast(0); } static constexpr long long signaling_NaN() noexcept { return static_cast(0); } static constexpr long long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned long long min() noexcept { return 0; } static constexpr unsigned long long max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } static constexpr unsigned long long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned long long epsilon() noexcept { return 0; } static constexpr unsigned long long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned long long infinity() noexcept { return static_cast(0); } static constexpr unsigned long long quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned long long signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned long long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 1644 "/usr/include/c++/15/limits" 3 __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; __extension__ template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 1676 "/usr/include/c++/15/limits" 3 template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr float min() noexcept { return 1.17549435082228750796873653722224568e-38F; } static constexpr float max() noexcept { return 3.40282346638528859811704183484516925e+38F; } static constexpr float lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr float epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } static constexpr float round_error() noexcept { return 0.5F; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr float infinity() noexcept { return __builtin_huge_valf(); } static constexpr float quiet_NaN() noexcept { return __builtin_nanf(""); } static constexpr float signaling_NaN() noexcept { return __builtin_nansf(""); } static constexpr float denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr double min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } static constexpr double max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } static constexpr double lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr double epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } static constexpr double round_error() noexcept { return 0.5; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr double infinity() noexcept { return __builtin_huge_val(); } static constexpr double quiet_NaN() noexcept { return __builtin_nan(""); } static constexpr double signaling_NaN() noexcept { return __builtin_nans(""); } static constexpr double denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr long double min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } static constexpr long double max() noexcept { return 1.18973149535723176508575932662800702e+4932L; } static constexpr long double lowest() noexcept { return -1.18973149535723176508575932662800702e+4932L; } static constexpr int digits = 113; static constexpr int digits10 = 33; static constexpr int max_digits10 = (2 + (113) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr long double epsilon() noexcept { return 1.92592994438723585305597794258492732e-34L; } static constexpr long double round_error() noexcept { return 0.5L; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr long double infinity() noexcept { return __builtin_huge_vall(); } static constexpr long double quiet_NaN() noexcept { return __builtin_nanl(""); } static constexpr long double signaling_NaN() noexcept { return __builtin_nansl(""); } static constexpr long double denorm_min() noexcept { return 6.47517511943802511092443895822764655e-4966L; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; # 1996 "/usr/include/c++/15/limits" 3 __extension__ template<> struct numeric_limits<_Float32> { static constexpr bool is_specialized = true; static constexpr _Float32 min() noexcept { return 1.17549435082228750796873653722224568e-38F32; } static constexpr _Float32 max() noexcept { return 3.40282346638528859811704183484516925e+38F32; } static constexpr _Float32 lowest() noexcept { return -3.40282346638528859811704183484516925e+38F32; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float32 epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F32; } static constexpr _Float32 round_error() noexcept { return 0.5F32; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float32 infinity() noexcept { return __builtin_huge_valf32(); } static constexpr _Float32 quiet_NaN() noexcept { return __builtin_nanf32(""); } static constexpr _Float32 signaling_NaN() noexcept { return __builtin_nansf32(""); } static constexpr _Float32 denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F32; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; __extension__ template<> struct numeric_limits<_Float64> { static constexpr bool is_specialized = true; static constexpr _Float64 min() noexcept { return 2.22507385850720138309023271733240406e-308F64; } static constexpr _Float64 max() noexcept { return 1.79769313486231570814527423731704357e+308F64; } static constexpr _Float64 lowest() noexcept { return -1.79769313486231570814527423731704357e+308F64; } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float64 epsilon() noexcept { return 2.22044604925031308084726333618164062e-16F64; } static constexpr _Float64 round_error() noexcept { return 0.5F64; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float64 infinity() noexcept { return __builtin_huge_valf64(); } static constexpr _Float64 quiet_NaN() noexcept { return __builtin_nanf64(""); } static constexpr _Float64 signaling_NaN() noexcept { return __builtin_nansf64(""); } static constexpr _Float64 denorm_min() noexcept { return 4.94065645841246544176568792868221372e-324F64; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; __extension__ template<> struct numeric_limits<_Float128> { static constexpr bool is_specialized = true; static constexpr _Float128 min() noexcept { return 3.36210314311209350626267781732175260e-4932F128; } static constexpr _Float128 max() noexcept { return 1.18973149535723176508575932662800702e+4932F128; } static constexpr _Float128 lowest() noexcept { return -1.18973149535723176508575932662800702e+4932F128; } static constexpr int digits = 113; static constexpr int digits10 = 33; static constexpr int max_digits10 = (2 + (113) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr _Float128 epsilon() noexcept { return 1.92592994438723585305597794258492732e-34F128; } static constexpr _Float128 round_error() noexcept { return 0.5F128; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr _Float128 infinity() noexcept { return __builtin_huge_valf128(); } static constexpr _Float128 quiet_NaN() noexcept { return __builtin_nanf128(""); } static constexpr _Float128 signaling_NaN() noexcept { return __builtin_nansf128(""); } static constexpr _Float128 denorm_min() noexcept { return 6.47517511943802511092443895822764655e-4966F128; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; # 2229 "/usr/include/c++/15/limits" 3 } # 2239 "/usr/include/c++/15/limits" 3 #pragma GCC diagnostic pop # 9 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" 2 # 16 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" namespace c10 { # 28 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" template class basic_string_view final { public: using value_type = CharT; using pointer = CharT*; using const_pointer = const CharT*; using reference = CharT&; using const_reference = const CharT&; using const_iterator = const CharT*; using iterator = const_iterator; using const_reverse_iterator = std::reverse_iterator; using reverse_iterator = const_reverse_iterator; using size_type = std::size_t; using difference_type = std::ptrdiff_t; static constexpr size_type npos = size_type(-1); constexpr basic_string_view() noexcept : begin_(nullptr) {} explicit constexpr basic_string_view(const_pointer str, size_type count) : begin_(str), size_(count) {} constexpr basic_string_view(const_pointer str) : basic_string_view(str, strlen_(str)) {} basic_string_view(const ::std::basic_string& str) : basic_string_view(str.data(), str.size()) {} constexpr basic_string_view( const ::std::basic_string_view& str) : basic_string_view(str.data(), str.size()) {} constexpr basic_string_view(const basic_string_view&) noexcept = default; constexpr basic_string_view& operator=( const basic_string_view& rhs) noexcept { begin_ = rhs.begin_; size_ = rhs.size_; return *this; } constexpr operator ::std::basic_string_view() const { return ::std::basic_string_view(data(), size()); } explicit operator ::std::basic_string() const { return ::std::basic_string(data(), size()); } constexpr const_iterator begin() const noexcept { return cbegin(); } constexpr const_iterator cbegin() const noexcept { return begin_; } constexpr const_iterator end() const noexcept { return cend(); } constexpr const_iterator cend() const noexcept { return begin_ + size_; } constexpr const_reverse_iterator rbegin() const noexcept { return crbegin(); } constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); } constexpr const_reverse_iterator rend() const noexcept { return crend(); } constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); } friend constexpr const_iterator begin(basic_string_view sv) noexcept { return sv.begin(); } friend constexpr const_iterator end(basic_string_view sv) noexcept { return sv.end(); } constexpr const_reference operator[](size_type pos) const { return at_(pos); } constexpr const_reference at(size_type pos) const { return (__builtin_expect(static_cast(pos >= size_), 0)) ? (throw std::out_of_range( "string_view::operator[] or string_view::at() out of range. Index: " + std::to_string(pos) + ", size: " + std::to_string(size())), at_(0)) : at_(pos); } constexpr const_reference front() const { return *begin_; } constexpr const_reference back() const { return *(begin_ + size_ - 1); } constexpr const_pointer data() const noexcept { return begin_; } constexpr size_type size() const noexcept { return size_; } constexpr size_type length() const noexcept { return size(); } constexpr size_type max_size() const noexcept { return std::numeric_limits::max(); } [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; } constexpr void remove_prefix(size_type n) { if (n > size()) { throw std::out_of_range( "basic_string_view::remove_prefix: out of range. PrefixLength: " + std::to_string(n) + ", size: " + std::to_string(size())); } begin_ += n; size_ -= n; } constexpr void remove_suffix(size_type n) { if (n > size()) { throw std::out_of_range( "basic_string_view::remove_suffix: out of range. SuffixLength: " + std::to_string(n) + ", size: " + std::to_string(size())); } size_ -= n; } constexpr void swap(basic_string_view& sv) noexcept { auto tmp = *this; *this = sv; sv = tmp; } size_type copy(pointer dest, size_type count, size_type pos = 0) const { if (pos > size_) { throw std::out_of_range( "basic_string_view::copy: out of range. Index: " + std::to_string(pos) + ", size: " + std::to_string(size())); } size_type copy_length = std::min(count, size_ - pos); for (auto iter = begin() + pos, end = iter + copy_length; iter != end;) { *(dest++) = *(iter++); } return copy_length; } constexpr basic_string_view substr(size_type pos = 0, size_type count = npos) const { return (pos > size_) ? (throw std::out_of_range( "basic_string_view::substr parameter out of bounds. Index: " + std::to_string(pos) + ", size: " + std::to_string(size())), substr_()) : substr_(pos, count); } constexpr int compare(basic_string_view rhs) const noexcept { for (size_t i = 0, end = std::min(size(), rhs.size()); i < end; ++i) { if (at_(i) < rhs.at_(i)) { return -1; } else if (at_(i) > rhs.at_(i)) { return 1; } } if (size() < rhs.size()) { return -1; } else if (size() > rhs.size()) { return 1; } return 0; } constexpr int compare(size_type pos1, size_type count1, basic_string_view v) const { return substr(pos1, count1).compare(v); } constexpr int compare( size_type pos1, size_type count1, basic_string_view v, size_type pos2, size_type count2) const { return substr(pos1, count1).compare(v.substr(pos2, count2)); } constexpr int compare(const_pointer s) const { return compare(basic_string_view(s)); } constexpr int compare(size_type pos1, size_type count1, const_pointer s) const { return substr(pos1, count1).compare(basic_string_view(s)); } constexpr int compare( size_type pos1, size_type count1, const_pointer s, size_type count2) const { return substr(pos1, count1).compare(basic_string_view(s, count2)); } friend constexpr bool operator==( basic_string_view lhs, basic_string_view rhs) noexcept { return lhs.equals_(rhs); } friend constexpr bool operator!=( basic_string_view lhs, basic_string_view rhs) noexcept { return !(lhs == rhs); } friend constexpr bool operator<( basic_string_view lhs, basic_string_view rhs) noexcept { return lhs.compare(rhs) < 0; } friend constexpr bool operator>=( basic_string_view lhs, basic_string_view rhs) noexcept { return !(lhs < rhs); } friend constexpr bool operator>( basic_string_view lhs, basic_string_view rhs) noexcept { return rhs < lhs; } friend constexpr bool operator<=( basic_string_view lhs, basic_string_view rhs) noexcept { return !(lhs > rhs); } constexpr bool starts_with(basic_string_view prefix) const noexcept { return (prefix.size() > size()) ? false : prefix.equals_(substr_(0, prefix.size())); } constexpr bool starts_with(CharT prefix) const noexcept { return !empty() && prefix == front(); } constexpr bool starts_with(const_pointer prefix) const { return starts_with(basic_string_view(prefix)); } constexpr bool ends_with(basic_string_view suffix) const noexcept { return (suffix.size() > size()) ? false : suffix.equals_(substr_(size() - suffix.size(), suffix.size())); } constexpr bool ends_with(CharT suffix) const noexcept { return !empty() && suffix == back(); } constexpr bool ends_with(const_pointer suffix) const { return ends_with(basic_string_view(suffix)); } constexpr size_type find(basic_string_view v, size_type pos = 0) const noexcept { if (v.size() == 0) { return pos <= size() ? pos : npos; } if (pos + v.size() <= size()) { for (size_type cur = pos, end = size() - v.size(); cur <= end; ++cur) { if (v.at_(0) == at_(cur) && v.substr_(1).equals_(substr_(cur + 1, v.size() - 1))) { return cur; } } } return npos; } constexpr size_type find(CharT ch, size_type pos = 0) const noexcept { return find_first_if_(pos, charIsEqual_{ch}); } constexpr size_type find(const_pointer s, size_type pos, size_type count) const { return find(basic_string_view(s, count), pos); } constexpr size_type find(const_pointer s, size_type pos = 0) const { return find(basic_string_view(s), pos); } constexpr size_type rfind(basic_string_view v, size_type pos = npos) const noexcept { if (v.size() == 0) { return pos <= size() ? pos : size(); } if (v.size() <= size()) { pos = std::min(size() - v.size(), pos); do { if (v.at_(0) == at_(pos) && v.substr_(1).equals_(substr_(pos + 1, v.size() - 1))) { return pos; } } while (pos-- > 0); } return npos; } constexpr size_type rfind(CharT ch, size_type pos = npos) const noexcept { return find_last_if_(pos, charIsEqual_{ch}); } constexpr size_type rfind(const_pointer s, size_type pos, size_type count) const { return rfind(basic_string_view(s, count), pos); } constexpr size_type rfind(const_pointer s, size_type pos = npos) const { return rfind(basic_string_view(s), pos); } constexpr size_type find_first_of(basic_string_view v, size_type pos = 0) const noexcept { return find_first_if_(pos, stringViewContainsChar_{v}); } constexpr size_type find_first_of(CharT ch, size_type pos = 0) const noexcept { return find_first_if_(pos, charIsEqual_{ch}); } constexpr size_type find_first_of( const_pointer s, size_type pos, size_type count) const { return find_first_of(basic_string_view(s, count), pos); } constexpr size_type find_first_of(const_pointer s, size_type pos = 0) const { return find_first_of(basic_string_view(s), pos); } constexpr size_type find_last_of(basic_string_view v, size_type pos = npos) const noexcept { return find_last_if_(pos, stringViewContainsChar_{v}); } constexpr size_type find_last_of(CharT ch, size_type pos = npos) const noexcept { return find_last_if_(pos, charIsEqual_{ch}); } constexpr size_type find_last_of( const_pointer s, size_type pos, size_type count) const { return find_last_of(basic_string_view(s, count), pos); } constexpr size_type find_last_of(const_pointer s, size_type pos = npos) const { return find_last_of(basic_string_view(s), pos); } constexpr size_type find_first_not_of(basic_string_view v, size_type pos = 0) const noexcept { return find_first_if_(pos, stringViewDoesNotContainChar_{v}); } constexpr size_type find_first_not_of(CharT ch, size_type pos = 0) const noexcept { return find_first_if_(pos, charIsNotEqual_{ch}); } constexpr size_type find_first_not_of( const_pointer s, size_type pos, size_type count) const { return find_first_not_of(basic_string_view(s, count), pos); } constexpr size_type find_first_not_of(const_pointer s, size_type pos = 0) const { return find_first_not_of(basic_string_view(s), pos); } constexpr size_type find_last_not_of( basic_string_view v, size_type pos = npos) const noexcept { return find_last_if_(pos, stringViewDoesNotContainChar_{v}); } constexpr size_type find_last_not_of(CharT ch, size_type pos = npos) const noexcept { return find_last_if_(pos, charIsNotEqual_{ch}); } constexpr size_type find_last_not_of( const_pointer s, size_type pos, size_type count) const { return find_last_not_of(basic_string_view(s, count), pos); } constexpr size_type find_last_not_of(const_pointer s, size_type pos = npos) const { return find_last_not_of(basic_string_view(s), pos); } private: static constexpr size_type strlen_(const_pointer str) noexcept { const_pointer current = str; while (*current != '\0') { ++current; } return current - str; } constexpr const_reference at_(size_type pos) const noexcept { return *(begin_ + pos); } constexpr basic_string_view substr_(size_type pos = 0, size_type count = npos) const { return basic_string_view{begin_ + pos, std::min(count, size() - pos)}; } template constexpr size_type find_first_if_(size_type pos, Condition&& condition) const noexcept { if (pos + 1 <= size()) { for (size_type cur = pos; cur < size(); ++cur) { if (condition(at_(cur))) { return cur; } } } return npos; } template constexpr size_type find_last_if_(size_type pos, Condition&& condition) const noexcept { if (size() > 0) { pos = std::min(size() - 1, pos); do { if (condition(at_(pos))) { return pos; } } while (pos-- > 0); } return npos; } constexpr bool equals_(basic_string_view rhs) const { return size() == rhs.size() && 0 == __builtin_memcmp(data(), rhs.data(), size()); # 549 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/string_view.h" } struct charIsEqual_ final { CharT expected; constexpr bool operator()(CharT actual) const noexcept { return expected == actual; } }; struct charIsNotEqual_ final { CharT expected; constexpr bool operator()(CharT actual) const noexcept { return expected != actual; } }; struct stringViewContainsChar_ final { basic_string_view expected; constexpr bool operator()(CharT ch) const noexcept { return npos != expected.find(ch); } }; struct stringViewDoesNotContainChar_ final { basic_string_view expected; constexpr bool operator()(CharT ch) const noexcept { return npos == expected.find(ch); } }; const_pointer begin_; size_type size_{}; }; template inline std::basic_ostream& operator<<( std::basic_ostream& stream, basic_string_view sv) { using std_string_type = ::std::basic_string_view; return stream << std_string_type(sv.data(), sv.size()); } template constexpr inline void swap( basic_string_view& lhs, basic_string_view& rhs) noexcept { lhs.swap(rhs); } using string_view = std::string_view; using c10_string_view = basic_string_view; constexpr bool starts_with( const std::string_view s, const std::string_view prefix) noexcept { return (prefix.size() > s.size()) ? false : prefix == s.substr(0, prefix.size()); } constexpr bool starts_with( const std::string_view s, const char prefix) noexcept { return !s.empty() && prefix == s.front(); } constexpr bool ends_with( const std::string_view s, const std::string_view suffix) noexcept { return (suffix.size() > s.size()) ? false : suffix == s.substr(s.size() - suffix.size(), suffix.size()); } constexpr bool ends_with(const std::string_view s, const char prefix) noexcept { return !s.empty() && prefix == s.back(); } } namespace std { template struct hash<::c10::basic_string_view> { size_t operator()(::c10::basic_string_view x) const { using std_string_type = ::std::basic_string_view; return ::std::hash{}(std_string_type(x.data(), x.size())); } }; } # 7 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/StringUtil.h" 2 # 1 "/usr/include/c++/15/optional" 1 3 # 40 "/usr/include/c++/15/optional" 3 # 1 "/usr/include/c++/15/bits/version.h" 1 3 # 41 "/usr/include/c++/15/optional" 2 3 # 61 "/usr/include/c++/15/optional" 3 # 61 "/usr/include/c++/15/optional" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class optional; struct nullopt_t { enum class _Construct { _Token }; explicit constexpr nullopt_t(_Construct) noexcept { } }; inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token }; template struct _Optional_func { _Fn& _M_f; }; class bad_optional_access : public exception { public: bad_optional_access() = default; virtual ~bad_optional_access() = default; const char* what() const noexcept override { return "bad optional access"; } }; [[__noreturn__]] inline void __throw_bad_optional_access() { (throw (bad_optional_access())); } template struct _Optional_payload_base { using _Stored_type = remove_const_t<_Tp>; _Optional_payload_base() = default; ~_Optional_payload_base() = default; template constexpr _Optional_payload_base(in_place_t __tag, _Args&&... __args) : _M_payload(__tag, std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload_base(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload_base(bool , const _Optional_payload_base& __other) { if (__other._M_engaged) this->_M_construct(__other._M_get()); } constexpr _Optional_payload_base(bool , _Optional_payload_base&& __other) { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); } _Optional_payload_base(const _Optional_payload_base&) = default; _Optional_payload_base(_Optional_payload_base&&) = default; _Optional_payload_base& operator=(const _Optional_payload_base&) = default; _Optional_payload_base& operator=(_Optional_payload_base&&) = default; constexpr void _M_copy_assign(const _Optional_payload_base& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } } constexpr void _M_move_assign(_Optional_payload_base&& __other) noexcept(__and_v, is_nothrow_move_assignable<_Tp>>) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = std::move(__other._M_get()); else { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); else this->_M_reset(); } } struct _Empty_byte { }; template> union _Storage { constexpr _Storage() noexcept : _M_empty() { } template constexpr _Storage(in_place_t, _Args&&... __args) : _M_value(std::forward<_Args>(__args)...) { } template constexpr _Storage(std::initializer_list<_Vp> __il, _Args&&... __args) : _M_value(__il, std::forward<_Args>(__args)...) { } # 245 "/usr/include/c++/15/optional" 3 _Empty_byte _M_empty; _Up _M_value; }; template union _Storage<_Up, false> { constexpr _Storage() noexcept : _M_empty() { } template constexpr _Storage(in_place_t, _Args&&... __args) : _M_value(std::forward<_Args>(__args)...) { } template constexpr _Storage(std::initializer_list<_Vp> __il, _Args&&... __args) : _M_value(__il, std::forward<_Args>(__args)...) { } # 277 "/usr/include/c++/15/optional" 3 ~_Storage() { } _Storage(const _Storage&) = default; _Storage(_Storage&&) = default; _Storage& operator=(const _Storage&) = default; _Storage& operator=(_Storage&&) = default; _Empty_byte _M_empty; _Up _M_value; }; _Storage<_Stored_type> _M_payload; bool _M_engaged = false; template constexpr void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) { std::_Construct(std::__addressof(this->_M_payload._M_value), std::forward<_Args>(__args)...); this->_M_engaged = true; } constexpr void _M_destroy() noexcept { _M_engaged = false; _M_payload._M_value.~_Stored_type(); } # 325 "/usr/include/c++/15/optional" 3 constexpr _Tp& _M_get() noexcept { return this->_M_payload._M_value; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload._M_value; } constexpr void _M_reset() noexcept { if (this->_M_engaged) _M_destroy(); else this->_M_engaged = false; } }; template , bool = is_trivially_copy_assignable_v<_Tp> && is_trivially_copy_constructible_v<_Tp>, bool = is_trivially_move_assignable_v<_Tp> && is_trivially_move_constructible_v<_Tp>> struct _Optional_payload; template struct _Optional_payload<_Tp, true, true, true> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; }; template struct _Optional_payload<_Tp, true, false, true> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; ~_Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; _Optional_payload& operator=(_Optional_payload&&) = default; constexpr _Optional_payload& operator=(const _Optional_payload& __other) { this->_M_copy_assign(__other); return *this; } }; template struct _Optional_payload<_Tp, true, true, false> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; ~_Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; _Optional_payload& operator=(const _Optional_payload&) = default; constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_v, is_nothrow_move_assignable<_Tp>>) { this->_M_move_assign(std::move(__other)); return *this; } }; template struct _Optional_payload<_Tp, true, false, false> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; ~_Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; constexpr _Optional_payload& operator=(const _Optional_payload& __other) { this->_M_copy_assign(__other); return *this; } constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_v, is_nothrow_move_assignable<_Tp>>) { this->_M_move_assign(std::move(__other)); return *this; } }; template struct _Optional_payload<_Tp, false, _Copy, _Move> : _Optional_payload<_Tp, true, false, false> { using _Optional_payload<_Tp, true, false, false>::_Optional_payload; _Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; _Optional_payload& operator=(const _Optional_payload&) = default; _Optional_payload& operator=(_Optional_payload&&) = default; ~_Optional_payload() { this->_M_reset(); } }; # 482 "/usr/include/c++/15/optional" 3 template, bool = is_trivially_move_constructible_v<_Tp>> struct _Optional_base { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } constexpr _Optional_base(const _Optional_base& __other) noexcept(is_nothrow_copy_constructible_v<_Tp>) : _M_payload(__other._M_payload._M_engaged, __other._M_payload) { } constexpr _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible_v<_Tp>) : _M_payload(__other._M_payload._M_engaged, std::move(__other._M_payload)) { } # 534 "/usr/include/c++/15/optional" 3 _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; _Optional_payload<_Tp> _M_payload; protected: using _Stored_type = remove_const_t<_Tp>; template constexpr void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) { _M_payload._M_construct(std::forward<_Args>(__args)...); } constexpr void _M_destruct() noexcept { _M_payload._M_destroy(); } constexpr void _M_reset() noexcept { _M_payload._M_reset(); } constexpr bool _M_is_engaged() const noexcept { return _M_payload._M_engaged; } constexpr _Tp& _M_get() noexcept { return _M_payload._M_get(); } constexpr const _Tp& _M_get() const noexcept { return _M_payload._M_get(); } }; # 586 "/usr/include/c++/15/optional" 3 template class _Optional_base_impl { protected: using _Stored_type = remove_const_t<_Tp>; template constexpr void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) { static_cast<_Dp*>(this)->_M_payload._M_construct( std::forward<_Args>(__args)...); } constexpr void _M_destruct() noexcept { static_cast<_Dp*>(this)->_M_payload._M_destroy(); } constexpr void _M_reset() noexcept { static_cast<_Dp*>(this)->_M_payload._M_reset(); } constexpr bool _M_is_engaged() const noexcept { return static_cast(this)->_M_payload._M_engaged; } constexpr _Tp& _M_get() noexcept { return static_cast<_Dp*>(this)->_M_payload._M_get(); } constexpr const _Tp& _M_get() const noexcept { return static_cast(this)->_M_payload._M_get(); } }; template struct _Optional_base<_Tp, false, true> : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } constexpr _Optional_base(const _Optional_base& __other) : _M_payload(__other._M_payload._M_engaged, __other._M_payload) { } constexpr _Optional_base(_Optional_base&& __other) = default; _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; _Optional_payload<_Tp> _M_payload; }; template struct _Optional_base<_Tp, true, false> : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } constexpr _Optional_base(const _Optional_base& __other) = default; constexpr _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible_v<_Tp>) : _M_payload(__other._M_payload._M_engaged, std::move(__other._M_payload)) { } _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; _Optional_payload<_Tp> _M_payload; }; template struct _Optional_base<_Tp, true, true> : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } constexpr _Optional_base(const _Optional_base& __other) = default; constexpr _Optional_base(_Optional_base&& __other) = default; _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; _Optional_payload<_Tp> _M_payload; }; template inline constexpr bool __is_optional_v = false; template inline constexpr bool __is_optional_v> = true; template using __converts_from_any_cvref = __or_< is_constructible<_Tp, _Wp&>, is_convertible<_Wp&, _Tp>, is_constructible<_Tp, _Wp>, is_convertible<_Wp, _Tp>, is_constructible<_Tp, const _Wp&>, is_convertible, is_constructible<_Tp, const _Wp>, is_convertible >; template using __converts_from_optional = __converts_from_any_cvref<_Tp, optional<_Up>>; template using __assigns_from_optional = __or_&>, is_assignable<_Tp&, optional<_Up>&>, is_assignable<_Tp&, const optional<_Up>&&>, is_assignable<_Tp&, optional<_Up>&&>>; # 777 "/usr/include/c++/15/optional" 3 template class optional : private _Optional_base<_Tp>, private _Enable_copy_move< is_copy_constructible_v<_Tp>, __and_v, is_copy_assignable<_Tp>>, is_move_constructible_v<_Tp>, __and_v, is_move_assignable<_Tp>>, optional<_Tp>> { static_assert(!is_same_v, nullopt_t>); static_assert(!is_same_v, in_place_t>); static_assert(is_object_v<_Tp> && !is_array_v<_Tp>); private: using _Base = _Optional_base<_Tp>; # 831 "/usr/include/c++/15/optional" 3 template> struct __not_constructing_bool_from_optional : true_type { }; template struct __not_constructing_bool_from_optional<_From, bool> : bool_constant>> { }; template> struct __construct_from_contained_value : __not_<__converts_from_optional<_Tp, _From>> { }; template struct __construct_from_contained_value<_From, bool> : true_type { }; template using __not_self = __not_>>; template using __not_tag = __not_>>; template using _Requires = enable_if_t<__and_v<_Cond...>, bool>; public: using value_type = _Tp; constexpr optional() noexcept { } constexpr optional(nullopt_t) noexcept { } # 919 "/usr/include/c++/15/optional" 3 template, _Requires<__not_self<_Up>, __not_tag<_Up>, is_constructible<_Tp, _Up>, is_convertible<_Up, _Tp>, __not_constructing_bool_from_optional<_Up>> = true> constexpr optional(_Up&& __t) noexcept(is_nothrow_constructible_v<_Tp, _Up>) : _Base(std::in_place, std::forward<_Up>(__t)) { } template, _Requires<__not_self<_Up>, __not_tag<_Up>, is_constructible<_Tp, _Up>, __not_>, __not_constructing_bool_from_optional<_Up>> = false> explicit constexpr optional(_Up&& __t) noexcept(is_nothrow_constructible_v<_Tp, _Up>) : _Base(std::in_place, std::forward<_Up>(__t)) { } template>, is_constructible<_Tp, const _Up&>, is_convertible, __construct_from_contained_value<_Up>> = true> constexpr optional(const optional<_Up>& __t) noexcept(is_nothrow_constructible_v<_Tp, const _Up&>) { if (__t) emplace(__t._M_get()); } template>, is_constructible<_Tp, const _Up&>, __not_>, __construct_from_contained_value<_Up>> = false> explicit constexpr optional(const optional<_Up>& __t) noexcept(is_nothrow_constructible_v<_Tp, const _Up&>) { if (__t) emplace(__t._M_get()); } template>, is_constructible<_Tp, _Up>, is_convertible<_Up, _Tp>, __construct_from_contained_value<_Up>> = true> constexpr optional(optional<_Up>&& __t) noexcept(is_nothrow_constructible_v<_Tp, _Up>) { if (__t) emplace(std::move(__t._M_get())); } template>, is_constructible<_Tp, _Up>, __not_>, __construct_from_contained_value<_Up>> = false> explicit constexpr optional(optional<_Up>&& __t) noexcept(is_nothrow_constructible_v<_Tp, _Up>) { if (__t) emplace(std::move(__t._M_get())); } template> = false> explicit constexpr optional(in_place_t, _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>) : _Base(std::in_place, std::forward<_Args>(__args)...) { } template&, _Args...>> = false> explicit constexpr optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { } optional& operator=(nullopt_t) noexcept { this->_M_reset(); return *this; } template> enable_if_t<__and_v<__not_self<_Up>, __not_<__and_, is_same<_Tp, decay_t<_Up>>>>, is_constructible<_Tp, _Up>, is_assignable<_Tp&, _Up>>, optional&> operator=(_Up&& __u) noexcept(__and_v, is_nothrow_assignable<_Tp&, _Up>>) { if (this->_M_is_engaged()) this->_M_get() = std::forward<_Up>(__u); else this->_M_construct(std::forward<_Up>(__u)); return *this; } template # 1053 "/usr/include/c++/15/optional" 3 enable_if_t<__and_v<__not_>, is_constructible<_Tp, const _Up&>, is_assignable<_Tp&, const _Up&>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>>>, optional&> operator=(const optional<_Up>& __u) noexcept(__and_v, is_nothrow_assignable<_Tp&, const _Up&>>) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = __u._M_get(); else this->_M_construct(__u._M_get()); } else { this->_M_reset(); } return *this; } template # 1087 "/usr/include/c++/15/optional" 3 enable_if_t<__and_v<__not_>, is_constructible<_Tp, _Up>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>>>, optional&> operator=(optional<_Up>&& __u) noexcept(__and_v, is_nothrow_assignable<_Tp&, _Up>>) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = std::move(__u._M_get()); else this->_M_construct(std::move(__u._M_get())); } else { this->_M_reset(); } return *this; } template enable_if_t, _Tp&> emplace(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>) { this->_M_reset(); this->_M_construct(std::forward<_Args>(__args)...); return this->_M_get(); } template enable_if_t&, _Args...>, _Tp&> emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) { this->_M_reset(); this->_M_construct(__il, std::forward<_Args>(__args)...); return this->_M_get(); } void swap(optional& __other) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>) { using std::swap; if (this->_M_is_engaged() && __other._M_is_engaged()) swap(this->_M_get(), __other._M_get()); else if (this->_M_is_engaged()) { __other._M_construct(std::move(this->_M_get())); this->_M_destruct(); } else if (__other._M_is_engaged()) { this->_M_construct(std::move(__other._M_get())); __other._M_destruct(); } } constexpr const _Tp* operator->() const noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false); return std::__addressof(this->_M_get()); } constexpr _Tp* operator->() noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false); return std::__addressof(this->_M_get()); } constexpr const _Tp& operator*() const& noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false); return this->_M_get(); } constexpr _Tp& operator*()& noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false); return this->_M_get(); } constexpr _Tp&& operator*()&& noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false); return std::move(this->_M_get()); } constexpr const _Tp&& operator*() const&& noexcept { do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false); return std::move(this->_M_get()); } constexpr explicit operator bool() const noexcept { return this->_M_is_engaged(); } constexpr bool has_value() const noexcept { return this->_M_is_engaged(); } constexpr const _Tp& value() const& { if (this->_M_is_engaged()) return this->_M_get(); __throw_bad_optional_access(); } constexpr _Tp& value()& { if (this->_M_is_engaged()) return this->_M_get(); __throw_bad_optional_access(); } constexpr _Tp&& value()&& { if (this->_M_is_engaged()) return std::move(this->_M_get()); __throw_bad_optional_access(); } constexpr const _Tp&& value() const&& { if (this->_M_is_engaged()) return std::move(this->_M_get()); __throw_bad_optional_access(); } template> constexpr _Tp value_or(_Up&& __u) const& { static_assert(is_copy_constructible_v<_Tp>); static_assert(is_convertible_v<_Up&&, _Tp>); if (this->_M_is_engaged()) return this->_M_get(); else return static_cast<_Tp>(std::forward<_Up>(__u)); } template> constexpr _Tp value_or(_Up&& __u) && { static_assert(is_move_constructible_v<_Tp>); static_assert(is_convertible_v<_Up&&, _Tp>); if (this->_M_is_engaged()) return std::move(this->_M_get()); else return static_cast<_Tp>(std::forward<_Up>(__u)); } # 1402 "/usr/include/c++/15/optional" 3 void reset() noexcept { this->_M_reset(); } private: using _Base::_M_get; template friend class optional; # 1417 "/usr/include/c++/15/optional" 3 }; template using __optional_relop_t = enable_if_t, bool>; template using __optional_eq_t = __optional_relop_t< decltype(std::declval() == std::declval()) >; template using __optional_ne_t = __optional_relop_t< decltype(std::declval() != std::declval()) >; template using __optional_lt_t = __optional_relop_t< decltype(std::declval() < std::declval()) >; template using __optional_gt_t = __optional_relop_t< decltype(std::declval() > std::declval()) >; template using __optional_le_t = __optional_relop_t< decltype(std::declval() <= std::declval()) >; template using __optional_ge_t = __optional_relop_t< decltype(std::declval() >= std::declval()) >; template constexpr auto operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_eq_t<_Tp, _Up> { return static_cast(__lhs) == static_cast(__rhs) && (!__lhs || *__lhs == *__rhs); } template constexpr auto operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_ne_t<_Tp, _Up> { return static_cast(__lhs) != static_cast(__rhs) || (static_cast(__lhs) && *__lhs != *__rhs); } template constexpr auto operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_lt_t<_Tp, _Up> { return static_cast(__rhs) && (!__lhs || *__lhs < *__rhs); } template constexpr auto operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_gt_t<_Tp, _Up> { return static_cast(__lhs) && (!__rhs || *__lhs > *__rhs); } template constexpr auto operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_le_t<_Tp, _Up> { return !__lhs || (static_cast(__rhs) && *__lhs <= *__rhs); } template constexpr auto operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_ge_t<_Tp, _Up> { return !__rhs || (static_cast(__lhs) && *__lhs >= *__rhs); } # 1515 "/usr/include/c++/15/optional" 3 template [[nodiscard]] constexpr bool operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } # 1528 "/usr/include/c++/15/optional" 3 template constexpr bool operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept { return !__rhs; } template constexpr bool operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept { return static_cast(__lhs); } template constexpr bool operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept { return static_cast(__rhs); } template constexpr bool operator<(const optional<_Tp>& , nullopt_t) noexcept { return false; } template constexpr bool operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept { return static_cast(__rhs); } template constexpr bool operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept { return static_cast(__lhs); } template constexpr bool operator>(nullopt_t, const optional<_Tp>& ) noexcept { return false; } template constexpr bool operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } template constexpr bool operator<=(nullopt_t, const optional<_Tp>& ) noexcept { return true; } template constexpr bool operator>=(const optional<_Tp>& , nullopt_t) noexcept { return true; } template constexpr bool operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept { return !__rhs; } # 1593 "/usr/include/c++/15/optional" 3 template constexpr auto operator== [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_eq_t<_Tp, _Up> { return __lhs && *__lhs == __rhs; } template constexpr auto operator== [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs) -> __optional_eq_t<_Tp, _Up> { return __rhs && __lhs == *__rhs; } template constexpr auto operator!= [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_ne_t<_Tp, _Up> { return !__lhs || *__lhs != __rhs; } template constexpr auto operator!= [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs) -> __optional_ne_t<_Tp, _Up> { return !__rhs || __lhs != *__rhs; } template constexpr auto operator< [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_lt_t<_Tp, _Up> { return !__lhs || *__lhs < __rhs; } template constexpr auto operator< [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs) -> __optional_lt_t<_Tp, _Up> { return __rhs && __lhs < *__rhs; } template constexpr auto operator> [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_gt_t<_Tp, _Up> { return __lhs && *__lhs > __rhs; } template constexpr auto operator> [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs) -> __optional_gt_t<_Tp, _Up> { return !__rhs || __lhs > *__rhs; } template constexpr auto operator<= [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_le_t<_Tp, _Up> { return !__lhs || *__lhs <= __rhs; } template constexpr auto operator<= [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs) -> __optional_le_t<_Tp, _Up> { return __rhs && __lhs <= *__rhs; } template constexpr auto operator>= [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_ge_t<_Tp, _Up> { return __lhs && *__lhs >= __rhs; } template constexpr auto operator>= [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs) -> __optional_ge_t<_Tp, _Up> { return !__rhs || __lhs >= *__rhs; } # 1699 "/usr/include/c++/15/optional" 3 template inline enable_if_t && is_swappable_v<_Tp>> swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } template enable_if_t && is_swappable_v<_Tp>)> swap(optional<_Tp>&, optional<_Tp>&) = delete; template constexpr enable_if_t, _Tp>, optional>> make_optional(_Tp&& __t) noexcept(is_nothrow_constructible_v>, _Tp>) { return optional>{ std::forward<_Tp>(__t) }; } template constexpr enable_if_t, optional<_Tp>> make_optional(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>) { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; } template constexpr enable_if_t&, _Args...>, optional<_Tp>> make_optional(initializer_list<_Up> __il, _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; } template> struct __optional_hash : public __hash_empty_base<_Up> { using result_type [[__deprecated__]] = size_t; using argument_type [[__deprecated__]] = optional<_Tp>; size_t operator()(const optional<_Tp>& __t) const noexcept(noexcept(hash<_Up>{}(*__t))) { constexpr size_t __magic_disengaged_hash = static_cast(-3333); return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash; } }; template struct hash> : public __conditional_t<__is_hash_enabled_for>, __optional_hash<_Tp>, __hash_not_enabled<_Tp>> { }; template struct __is_fast_hash>> : __is_fast_hash> { }; template optional(_Tp) -> optional<_Tp>; } # 10 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/StringUtil.h" 2 # 1 "/usr/include/c++/15/sstream" 1 3 # 42 "/usr/include/c++/15/sstream" 3 # 1 "/usr/include/c++/15/istream" 1 3 # 45 "/usr/include/c++/15/istream" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 61 "/usr/include/c++/15/istream" 3 template class basic_istream : virtual public basic_ios<_CharT, _Traits> { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_ios<_CharT, _Traits> __ios_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > __num_get_type; typedef ctype<_CharT> __ctype_type; protected: streamsize _M_gcount; public: explicit basic_istream(__streambuf_type* __sb) : _M_gcount(streamsize(0)) { this->init(__sb); } virtual ~basic_istream() { _M_gcount = streamsize(0); } class sentry; friend class sentry; # 123 "/usr/include/c++/15/istream" 3 __istream_type& operator>>(__istream_type& (*__pf)(__istream_type&)) { return __pf(*this); } __istream_type& operator>>(__ios_type& (*__pf)(__ios_type&)) { __pf(*this); return *this; } __istream_type& operator>>(ios_base& (*__pf)(ios_base&)) { __pf(*this); return *this; } # 171 "/usr/include/c++/15/istream" 3 __istream_type& operator>>(bool& __n) { return _M_extract(__n); } __istream_type& operator>>(short& __n); __istream_type& operator>>(unsigned short& __n) { return _M_extract(__n); } __istream_type& operator>>(int& __n); __istream_type& operator>>(unsigned int& __n) { return _M_extract(__n); } __istream_type& operator>>(long& __n) { return _M_extract(__n); } __istream_type& operator>>(unsigned long& __n) { return _M_extract(__n); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" __istream_type& operator>>(long long& __n) { return _M_extract(__n); } __istream_type& operator>>(unsigned long long& __n) { return _M_extract(__n); } #pragma GCC diagnostic pop # 220 "/usr/include/c++/15/istream" 3 __istream_type& operator>>(float& __f) { return _M_extract(__f); } __istream_type& operator>>(double& __f) { return _M_extract(__f); } __istream_type& operator>>(long double& __f) { return _M_extract(__f); } # 329 "/usr/include/c++/15/istream" 3 __istream_type& operator>>(void*& __p) { return _M_extract(__p); } # 353 "/usr/include/c++/15/istream" 3 __istream_type& operator>>(__streambuf_type* __sb); # 363 "/usr/include/c++/15/istream" 3 streamsize gcount() const { return _M_gcount; } # 396 "/usr/include/c++/15/istream" 3 int_type get(); # 410 "/usr/include/c++/15/istream" 3 __istream_type& get(char_type& __c); # 437 "/usr/include/c++/15/istream" 3 __istream_type& get(char_type* __s, streamsize __n, char_type __delim); # 448 "/usr/include/c++/15/istream" 3 __istream_type& get(char_type* __s, streamsize __n) { return this->get(__s, __n, this->widen('\n')); } # 471 "/usr/include/c++/15/istream" 3 __istream_type& get(__streambuf_type& __sb, char_type __delim); # 481 "/usr/include/c++/15/istream" 3 __istream_type& get(__streambuf_type& __sb) { return this->get(__sb, this->widen('\n')); } # 510 "/usr/include/c++/15/istream" 3 __istream_type& getline(char_type* __s, streamsize __n, char_type __delim); # 521 "/usr/include/c++/15/istream" 3 __istream_type& getline(char_type* __s, streamsize __n) { return this->getline(__s, __n, this->widen('\n')); } # 545 "/usr/include/c++/15/istream" 3 __istream_type& ignore(streamsize __n, int_type __delim); __istream_type& ignore(streamsize __n); __istream_type& ignore(); # 562 "/usr/include/c++/15/istream" 3 int_type peek(); # 580 "/usr/include/c++/15/istream" 3 __istream_type& read(char_type* __s, streamsize __n); # 599 "/usr/include/c++/15/istream" 3 streamsize readsome(char_type* __s, streamsize __n); # 616 "/usr/include/c++/15/istream" 3 __istream_type& putback(char_type __c); # 632 "/usr/include/c++/15/istream" 3 __istream_type& unget(); # 650 "/usr/include/c++/15/istream" 3 int sync(); # 665 "/usr/include/c++/15/istream" 3 pos_type tellg(); # 680 "/usr/include/c++/15/istream" 3 __istream_type& seekg(pos_type); # 696 "/usr/include/c++/15/istream" 3 __istream_type& seekg(off_type, ios_base::seekdir); protected: basic_istream() : _M_gcount(streamsize(0)) { this->init(0); } basic_istream(const basic_istream&) = delete; basic_istream(basic_istream&& __rhs) : __ios_type(), _M_gcount(__rhs._M_gcount) { __ios_type::move(__rhs); __rhs._M_gcount = 0; } basic_istream& operator=(const basic_istream&) = delete; basic_istream& operator=(basic_istream&& __rhs) { swap(__rhs); return *this; } void swap(basic_istream& __rhs) { __ios_type::swap(__rhs); std::swap(_M_gcount, __rhs._M_gcount); } template __istream_type& _M_extract(_ValueT& __v); }; template<> basic_istream& basic_istream:: getline(char_type* __s, streamsize __n, char_type __delim); template<> basic_istream& basic_istream:: ignore(streamsize __n); template<> basic_istream& basic_istream:: ignore(streamsize __n, int_type __delim); template<> basic_istream& basic_istream:: getline(char_type* __s, streamsize __n, char_type __delim); template<> basic_istream& basic_istream:: ignore(streamsize __n); template<> basic_istream& basic_istream:: ignore(streamsize __n, int_type __delim); # 780 "/usr/include/c++/15/istream" 3 template class basic_istream<_CharT, _Traits>::sentry { bool _M_ok; public: typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::__ctype_type __ctype_type; typedef typename _Traits::int_type __int_type; # 816 "/usr/include/c++/15/istream" 3 explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); # 827 "/usr/include/c++/15/istream" 3 explicit operator bool() const { return _M_ok; } }; # 845 "/usr/include/c++/15/istream" 3 template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); template inline basic_istream& operator>>(basic_istream& __in, unsigned char& __c) { return (__in >> reinterpret_cast(__c)); } template inline basic_istream& operator>>(basic_istream& __in, signed char& __c) { return (__in >> reinterpret_cast(__c)); } template void __istream_extract(basic_istream<_CharT, _Traits>&, _CharT*, streamsize); void __istream_extract(istream&, char*, streamsize); # 895 "/usr/include/c++/15/istream" 3 template __attribute__((__nonnull__(2), __access__(__write_only__, 2))) inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) { size_t __n = __builtin_object_size(__s, 0); if (__n < sizeof(_CharT)) { do { if (std::__is_constant_evaluated() && !bool(__n >= sizeof(_CharT))) std::__glibcxx_assert_fail(); } while (false); __in.width(0); __in.setstate(ios_base::failbit); } else if (__n != (size_t)-1) { __n /= sizeof(_CharT); streamsize __w = __in.width(); std::__istream_extract(__in, __s, __n); if (__in.good() && (__w <= 0 || __n < (size_t)__w)) { const typename _Traits::int_type __c = __in.rdbuf()->sgetc(); const bool __eof = _Traits::eq_int_type(__c, _Traits::eof()); if (__builtin_expect(__eof, true)) __in.setstate(ios_base::eofbit); } } else { streamsize __n = __gnu_cxx::__numeric_traits::__max; __n /= sizeof(_CharT); std::__istream_extract(__in, __s, __n); } return __in; } template __attribute__((__nonnull__(2), __access__(__write_only__, 2))) inline basic_istream& operator>>(basic_istream& __in, unsigned char* __s) { return __in >> reinterpret_cast(__s); } template __attribute__((__nonnull__(2), __access__(__write_only__, 2))) inline basic_istream& operator>>(basic_istream& __in, signed char* __s) { return __in >> reinterpret_cast(__s); } # 984 "/usr/include/c++/15/istream" 3 template class basic_iostream : public basic_istream<_CharT, _Traits>, public basic_ostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_ostream<_CharT, _Traits> __ostream_type; explicit basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) : __istream_type(__sb), __ostream_type(__sb) { } virtual ~basic_iostream() { } protected: basic_iostream() : __istream_type(), __ostream_type() { } basic_iostream(const basic_iostream&) = delete; basic_iostream(basic_iostream&& __rhs) : __istream_type(std::move(__rhs)), __ostream_type(*this) { } basic_iostream& operator=(const basic_iostream&) = delete; basic_iostream& operator=(basic_iostream&& __rhs) { swap(__rhs); return *this; } void swap(basic_iostream& __rhs) { __istream_type::swap(__rhs); } }; # 1067 "/usr/include/c++/15/istream" 3 template basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __is); # 1083 "/usr/include/c++/15/istream" 3 template, typename = decltype(std::declval<_Is&>() >> std::declval<_Tp>())> using __rvalue_stream_extraction_t = _Is&&; # 1099 "/usr/include/c++/15/istream" 3 template inline __rvalue_stream_extraction_t<_Istream, _Tp> operator>>(_Istream&& __is, _Tp&& __x) { __is >> std::forward<_Tp>(__x); return std::move(__is); } } # 1 "/usr/include/c++/15/bits/istream.tcc" 1 3 # 41 "/usr/include/c++/15/bits/istream.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template basic_istream<_CharT, _Traits>::sentry:: sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) { ios_base::iostate __err = ios_base::goodbit; if (__in.good()) { try { if (__in.tie()) __in.tie()->flush(); if (!__noskip && bool(__in.flags() & ios_base::skipws)) { const __int_type __eof = traits_type::eof(); __streambuf_type* __sb = __in.rdbuf(); __int_type __c = __sb->sgetc(); const __ctype_type& __ct = __check_facet(__in._M_ctype); while (!traits_type::eq_int_type(__c, __eof) && __ct.is(ctype_base::space, traits_type::to_char_type(__c))) __c = __sb->snextc(); if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } } if (__in.good() && __err == ios_base::goodbit) _M_ok = true; else { __err |= ios_base::failbit; __in.setstate(__err); } } template template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: _M_extract(_ValueT& __v) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __num_get_type& __ng = __check_facet(this->_M_num_get); __ng.get(*this, 0, *this, __err, __v); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(short& __n) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { long __l; const __num_get_type& __ng = __check_facet(this->_M_num_get); __ng.get(*this, 0, *this, __err, __l); if (__l < __gnu_cxx::__numeric_traits::__min) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__min; } else if (__l > __gnu_cxx::__numeric_traits::__max) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__max; } else __n = short(__l); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(int& __n) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { long __l; const __num_get_type& __ng = __check_facet(this->_M_num_get); __ng.get(*this, 0, *this, __err, __l); if (__l < __gnu_cxx::__numeric_traits::__min) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__min; } else if (__l > __gnu_cxx::__numeric_traits::__max) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__max; } else __n = int(__l); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(__streambuf_type* __sbout) { ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, false); if (__cerb && __sbout) { try { bool __ineof; if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) __err |= ios_base::failbit; if (__ineof) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::failbit); throw; } catch(...) { this->_M_setstate(ios_base::failbit); } } else if (!__sbout) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>:: get(void) { const int_type __eof = traits_type::eof(); int_type __c = __eof; _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { __c = this->rdbuf()->sbumpc(); if (!traits_type::eq_int_type(__c, __eof)) _M_gcount = 1; else __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return __c; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(char_type& __c) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __cb = this->rdbuf()->sbumpc(); if (!traits_type::eq_int_type(__cb, traits_type::eof())) { _M_gcount = 1; __c = traits_type::to_char_type(__cb); } else __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(char_type* __s, streamsize __n, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); while (_M_gcount + 1 < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __idelim)) { *__s++ = traits_type::to_char_type(__c); ++_M_gcount; __c = __sb->snextc(); } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (__n > 0) *__s = char_type(); if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(__streambuf_type& __sb, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type* __this_sb = this->rdbuf(); int_type __c = __this_sb->sgetc(); char_type __c2 = traits_type::to_char_type(__c); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" unsigned long long __gcount = 0; #pragma GCC diagnostic pop while (!traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __idelim) && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) { ++__gcount; __c = __this_sb->snextc(); __c2 = traits_type::to_char_type(__c); } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; if (__gcount <= __gnu_cxx::__numeric_traits::__max) _M_gcount = __gcount; else _M_gcount = __gnu_cxx::__numeric_traits::__max; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: getline(char_type* __s, streamsize __n, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); while (_M_gcount + 1 < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __idelim)) { *__s++ = traits_type::to_char_type(__c); __c = __sb->snextc(); ++_M_gcount; } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; else { if (traits_type::eq_int_type(__c, __idelim)) { __sb->sbumpc(); ++_M_gcount; } else __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (__n > 0) *__s = char_type(); if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(void) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) __err |= ios_base::eofbit; else _M_gcount = 1; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb && __n > 0) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); # 553 "/usr/include/c++/15/bits/istream.tcc" 3 bool __large_ignore = false; while (true) { while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof)) { ++_M_gcount; __c = __sb->snextc(); } if (__n == __gnu_cxx::__numeric_traits::__max && !traits_type::eq_int_type(__c, __eof)) { _M_gcount = __gnu_cxx::__numeric_traits::__min; __large_ignore = true; } else break; } if (__n == __gnu_cxx::__numeric_traits::__max) { if (__large_ignore) _M_gcount = __gnu_cxx::__numeric_traits::__max; if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } else if (_M_gcount < __n) { if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(streamsize __n, int_type __delim) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb && __n > 0) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); bool __large_ignore = false; while (true) { while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __delim)) { ++_M_gcount; __c = __sb->snextc(); } if (__n == __gnu_cxx::__numeric_traits::__max && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __delim)) { _M_gcount = __gnu_cxx::__numeric_traits::__min; __large_ignore = true; } else break; } if (__n == __gnu_cxx::__numeric_traits::__max) { if (__large_ignore) _M_gcount = __gnu_cxx::__numeric_traits::__max; if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; else { if (_M_gcount != __n) ++_M_gcount; __sb->sbumpc(); } } else if (_M_gcount < __n) { if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; else { ++_M_gcount; __sb->sbumpc(); } } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>:: peek(void) { int_type __c = traits_type::eof(); _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { __c = this->rdbuf()->sgetc(); if (traits_type::eq_int_type(__c, traits_type::eof())) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return __c; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: read(char_type* __s, streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { _M_gcount = this->rdbuf()->sgetn(__s, __n); if (_M_gcount != __n) __err |= (ios_base::eofbit | ios_base::failbit); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template streamsize basic_istream<_CharT, _Traits>:: readsome(char_type* __s, streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const streamsize __num = this->rdbuf()->in_avail(); if (__num > 0) _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); else if (__num == -1) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return _M_gcount; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: putback(char_type __c) { _M_gcount = 0; this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); if (!__sb || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: unget(void) { _M_gcount = 0; this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); if (!__sb || traits_type::eq_int_type(__sb->sungetc(), __eof)) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template int basic_istream<_CharT, _Traits>:: sync(void) { int __ret = -1; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { __streambuf_type* __sb = this->rdbuf(); if (__sb) { if (__sb->pubsync() == -1) __err |= ios_base::badbit; else __ret = 0; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return __ret; } template typename basic_istream<_CharT, _Traits>::pos_type basic_istream<_CharT, _Traits>:: tellg(void) { pos_type __ret = pos_type(-1); sentry __cerb(*this, true); if (__cerb) { try { if (!this->fail()) __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } return __ret; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: seekg(pos_type __pos) { this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::in); if (__p == pos_type(off_type(-1))) __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: seekg(off_type __off, ios_base::seekdir __dir) { this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, ios_base::in); if (__p == pos_type(off_type(-1))) __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::int_type __int_type; typename __istream_type::sentry __cerb(__in, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __int_type __cb = __in.rdbuf()->sbumpc(); if (!_Traits::eq_int_type(__cb, _Traits::eof())) __c = _Traits::to_char_type(__cb); else __err |= (ios_base::eofbit | ios_base::failbit); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } if (__err) __in.setstate(__err); } return __in; } template void __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s, streamsize __num) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef typename _Traits::int_type int_type; typedef _CharT char_type; typedef ctype<_CharT> __ctype_type; streamsize __extracted = 0; ios_base::iostate __err = ios_base::goodbit; typename __istream_type::sentry __cerb(__in, false); if (__cerb) { try { streamsize __width = __in.width(); if (0 < __width && __width < __num) __num = __width; const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); const int_type __eof = _Traits::eof(); __streambuf_type* __sb = __in.rdbuf(); int_type __c = __sb->sgetc(); while (__extracted < __num - 1 && !_Traits::eq_int_type(__c, __eof) && !__ct.is(ctype_base::space, _Traits::to_char_type(__c))) { *__s++ = _Traits::to_char_type(__c); ++__extracted; __c = __sb->snextc(); } if (__extracted < __num - 1 && _Traits::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; *__s = char_type(); __in.width(0); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } } if (!__extracted) __err |= ios_base::failbit; if (__err) __in.setstate(__err); } template basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __in) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef typename __istream_type::int_type __int_type; typedef ctype<_CharT> __ctype_type; typename __istream_type::sentry __cerb(__in, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); const __int_type __eof = _Traits::eof(); __streambuf_type* __sb = __in.rdbuf(); __int_type __c = __sb->sgetc(); while (true) { if (_Traits::eq_int_type(__c, __eof)) { __err = ios_base::eofbit; break; } if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c))) break; __c = __sb->snextc(); } } catch(const __cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } if (__err) __in.setstate(__err); } return __in; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" #pragma GCC diagnostic ignored "-Wlong-long" extern template class basic_istream; extern template istream& ws(istream&); extern template istream& operator>>(istream&, char&); extern template istream& operator>>(istream&, unsigned char&); extern template istream& operator>>(istream&, signed char&); extern template istream& istream::_M_extract(unsigned short&); extern template istream& istream::_M_extract(unsigned int&); extern template istream& istream::_M_extract(long&); extern template istream& istream::_M_extract(unsigned long&); extern template istream& istream::_M_extract(bool&); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wlong-long" extern template istream& istream::_M_extract(long long&); extern template istream& istream::_M_extract(unsigned long long&); #pragma GCC diagnostic pop extern template istream& istream::_M_extract(float&); extern template istream& istream::_M_extract(double&); extern template istream& istream::_M_extract(long double&); extern template istream& istream::_M_extract(void*&); extern template class basic_iostream; extern template class basic_istream; extern template wistream& ws(wistream&); extern template wistream& operator>>(wistream&, wchar_t&); extern template void __istream_extract(wistream&, wchar_t*, streamsize); extern template wistream& wistream::_M_extract(unsigned short&); extern template wistream& wistream::_M_extract(unsigned int&); extern template wistream& wistream::_M_extract(long&); extern template wistream& wistream::_M_extract(unsigned long&); extern template wistream& wistream::_M_extract(bool&); extern template wistream& wistream::_M_extract(long long&); extern template wistream& wistream::_M_extract(unsigned long long&); extern template wistream& wistream::_M_extract(float&); extern template wistream& wistream::_M_extract(double&); extern template wistream& wistream::_M_extract(long double&); extern template wistream& wistream::_M_extract(void*&); extern template class basic_iostream; #pragma GCC diagnostic pop } #pragma GCC diagnostic pop # 1112 "/usr/include/c++/15/istream" 2 3 # 43 "/usr/include/c++/15/sstream" 2 3 # 57 "/usr/include/c++/15/sstream" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { # 80 "/usr/include/c++/15/sstream" 3 template class basic_stringbuf : public basic_streambuf<_CharT, _Traits> { struct __xfer_bufptrs; using allocator_traits = std::allocator_traits<_Alloc>; using _Noexcept_swap = __or_; public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_streambuf __streambuf_type; typedef basic_string __string_type; typedef typename __string_type::size_type __size_type; protected: ios_base::openmode _M_mode; __string_type _M_string; public: # 123 "/usr/include/c++/15/sstream" 3 basic_stringbuf() : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string() { } # 134 "/usr/include/c++/15/sstream" 3 explicit basic_stringbuf(ios_base::openmode __mode) : __streambuf_type(), _M_mode(__mode), _M_string() { } # 147 "/usr/include/c++/15/sstream" 3 explicit basic_stringbuf(const __string_type& __str, ios_base::openmode __mode = ios_base::in | ios_base::out) : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size(), __str.get_allocator()) { _M_stringbuf_init(__mode); } basic_stringbuf(const basic_stringbuf&) = delete; basic_stringbuf(basic_stringbuf&& __rhs) : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this)) { __rhs._M_sync(const_cast(__rhs._M_string.data()), 0, 0); } # 211 "/usr/include/c++/15/sstream" 3 basic_stringbuf& operator=(const basic_stringbuf&) = delete; basic_stringbuf& operator=(basic_stringbuf&& __rhs) { __xfer_bufptrs __st{__rhs, this}; const __streambuf_type& __base = __rhs; __streambuf_type::operator=(__base); this->pubimbue(__rhs.getloc()); _M_mode = __rhs._M_mode; _M_string = std::move(__rhs._M_string); __rhs._M_sync(const_cast(__rhs._M_string.data()), 0, 0); return *this; } void swap(basic_stringbuf& __rhs) noexcept(_Noexcept_swap::value) { __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)}; __xfer_bufptrs __r_st{__rhs, this}; __streambuf_type& __base = __rhs; __streambuf_type::swap(__base); __rhs.pubimbue(this->pubimbue(__rhs.getloc())); std::swap(_M_mode, __rhs._M_mode); std::swap(_M_string, __rhs._M_string); } # 250 "/usr/include/c++/15/sstream" 3 [[__nodiscard__]] __string_type str() const { __string_type __ret(_M_string.get_allocator()); if (char_type* __hi = _M_high_mark()) __ret.assign(this->pbase(), __hi); else __ret = _M_string; return __ret; } # 309 "/usr/include/c++/15/sstream" 3 void str(const __string_type& __s) { _M_string.assign(__s.data(), __s.size()); _M_stringbuf_init(_M_mode); } # 338 "/usr/include/c++/15/sstream" 3 protected: void _M_stringbuf_init(ios_base::openmode __mode) { _M_mode = __mode; __size_type __len = 0; if (_M_mode & (ios_base::ate | ios_base::app)) __len = _M_string.size(); _M_sync(const_cast(_M_string.data()), 0, __len); } virtual streamsize showmanyc() { streamsize __ret = -1; if (_M_mode & ios_base::in) { _M_update_egptr(); __ret = this->egptr() - this->gptr(); } return __ret; } virtual int_type underflow(); virtual int_type pbackfail(int_type __c = traits_type::eof()); virtual int_type overflow(int_type __c = traits_type::eof()); # 382 "/usr/include/c++/15/sstream" 3 virtual __streambuf_type* setbuf(char_type* __s, streamsize __n) { if (__s && __n >= 0) { _M_string.clear(); _M_sync(__s, __n, 0); } return this; } virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type __sp, ios_base::openmode __mode = ios_base::in | ios_base::out); void _M_sync(char_type* __base, __size_type __i, __size_type __o); void _M_update_egptr() { if (char_type* __pptr = this->pptr()) { char_type* __egptr = this->egptr(); if (!__egptr || __pptr > __egptr) { if (_M_mode & ios_base::in) this->setg(this->eback(), this->gptr(), __pptr); else this->setg(__pptr, __pptr, __pptr); } } } void _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off); private: __attribute__((__always_inline__)) char_type* _M_high_mark() const noexcept { if (char_type* __pptr = this->pptr()) { char_type* __egptr = this->egptr(); if (!__egptr || __pptr > __egptr) return __pptr; else return __egptr; } return 0; } struct __xfer_bufptrs { __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to) : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1} { const _CharT* const __str = __from._M_string.data(); const _CharT* __end = nullptr; if (__from.eback()) { _M_goff[0] = __from.eback() - __str; _M_goff[1] = __from.gptr() - __str; _M_goff[2] = __from.egptr() - __str; __end = __from.egptr(); } if (__from.pbase()) { _M_poff[0] = __from.pbase() - __str; _M_poff[1] = __from.pptr() - __from.pbase(); _M_poff[2] = __from.epptr() - __str; if (!__end || __from.pptr() > __end) __end = __from.pptr(); } if (__end) { auto& __mut_from = const_cast(__from); __mut_from._M_string._M_length(__end - __str); } } ~__xfer_bufptrs() { char_type* __str = const_cast(_M_to->_M_string.data()); if (_M_goff[0] != -1) _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]); if (_M_poff[0] != -1) _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]); } basic_stringbuf* _M_to; off_type _M_goff[3]; off_type _M_poff[3]; }; # 518 "/usr/include/c++/15/sstream" 3 basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&) : __streambuf_type(static_cast(__rhs)), _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string)) { } # 533 "/usr/include/c++/15/sstream" 3 }; # 551 "/usr/include/c++/15/sstream" 3 template class basic_istringstream : public basic_istream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_istream __istream_type; private: __stringbuf_type _M_stringbuf; public: # 585 "/usr/include/c++/15/sstream" 3 basic_istringstream() : __istream_type(), _M_stringbuf(ios_base::in) { this->init(&_M_stringbuf); } # 601 "/usr/include/c++/15/sstream" 3 explicit basic_istringstream(ios_base::openmode __mode) : __istream_type(), _M_stringbuf(__mode | ios_base::in) { this->init(&_M_stringbuf); } # 619 "/usr/include/c++/15/sstream" 3 explicit basic_istringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::in) : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) { this->init(&_M_stringbuf); } ~basic_istringstream() { } basic_istringstream(const basic_istringstream&) = delete; basic_istringstream(basic_istringstream&& __rhs) : __istream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __istream_type::set_rdbuf(&_M_stringbuf); } # 676 "/usr/include/c++/15/sstream" 3 basic_istringstream& operator=(const basic_istringstream&) = delete; basic_istringstream& operator=(basic_istringstream&& __rhs) { __istream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_istringstream& __rhs) { __istream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } # 702 "/usr/include/c++/15/sstream" 3 [[__nodiscard__]] __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } [[__nodiscard__]] __string_type str() const { return _M_stringbuf.str(); } # 744 "/usr/include/c++/15/sstream" 3 void str(const __string_type& __s) { _M_stringbuf.str(__s); } # 761 "/usr/include/c++/15/sstream" 3 }; # 779 "/usr/include/c++/15/sstream" 3 template class basic_ostringstream : public basic_ostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_ostream __ostream_type; private: __stringbuf_type _M_stringbuf; public: # 813 "/usr/include/c++/15/sstream" 3 basic_ostringstream() : __ostream_type(), _M_stringbuf(ios_base::out) { this->init(&_M_stringbuf); } # 829 "/usr/include/c++/15/sstream" 3 explicit basic_ostringstream(ios_base::openmode __mode) : __ostream_type(), _M_stringbuf(__mode | ios_base::out) { this->init(&_M_stringbuf); } # 847 "/usr/include/c++/15/sstream" 3 explicit basic_ostringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::out) : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) { this->init(&_M_stringbuf); } ~basic_ostringstream() { } basic_ostringstream(const basic_ostringstream&) = delete; basic_ostringstream(basic_ostringstream&& __rhs) : __ostream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __ostream_type::set_rdbuf(&_M_stringbuf); } # 904 "/usr/include/c++/15/sstream" 3 basic_ostringstream& operator=(const basic_ostringstream&) = delete; basic_ostringstream& operator=(basic_ostringstream&& __rhs) { __ostream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_ostringstream& __rhs) { __ostream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } # 930 "/usr/include/c++/15/sstream" 3 [[__nodiscard__]] __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } [[__nodiscard__]] __string_type str() const { return _M_stringbuf.str(); } # 972 "/usr/include/c++/15/sstream" 3 void str(const __string_type& __s) { _M_stringbuf.str(__s); } # 989 "/usr/include/c++/15/sstream" 3 }; # 1007 "/usr/include/c++/15/sstream" 3 template class basic_stringstream : public basic_iostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_iostream __iostream_type; private: __stringbuf_type _M_stringbuf; public: # 1041 "/usr/include/c++/15/sstream" 3 basic_stringstream() : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in) { this->init(&_M_stringbuf); } # 1055 "/usr/include/c++/15/sstream" 3 explicit basic_stringstream(ios_base::openmode __m) : __iostream_type(), _M_stringbuf(__m) { this->init(&_M_stringbuf); } # 1071 "/usr/include/c++/15/sstream" 3 explicit basic_stringstream(const __string_type& __str, ios_base::openmode __m = ios_base::out | ios_base::in) : __iostream_type(), _M_stringbuf(__str, __m) { this->init(&_M_stringbuf); } ~basic_stringstream() { } basic_stringstream(const basic_stringstream&) = delete; basic_stringstream(basic_stringstream&& __rhs) : __iostream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __iostream_type::set_rdbuf(&_M_stringbuf); } # 1130 "/usr/include/c++/15/sstream" 3 basic_stringstream& operator=(const basic_stringstream&) = delete; basic_stringstream& operator=(basic_stringstream&& __rhs) { __iostream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_stringstream& __rhs) { __iostream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } # 1156 "/usr/include/c++/15/sstream" 3 [[__nodiscard__]] __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } [[__nodiscard__]] __string_type str() const { return _M_stringbuf.str(); } # 1198 "/usr/include/c++/15/sstream" 3 void str(const __string_type& __s) { _M_stringbuf.str(__s); } # 1215 "/usr/include/c++/15/sstream" 3 }; template inline void swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, basic_stringbuf<_CharT, _Traits, _Allocator>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline void swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x, basic_istringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } template inline void swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x, basic_ostringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } template inline void swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x, basic_stringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } } } # 1 "/usr/include/c++/15/bits/sstream.tcc" 1 3 # 40 "/usr/include/c++/15/bits/sstream.tcc" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++11-extensions" namespace std __attribute__ ((__visibility__ ("default"))) { template typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type basic_stringbuf<_CharT, _Traits, _Alloc>:: pbackfail(int_type __c) { int_type __ret = traits_type::eof(); if (this->eback() < this->gptr()) { const bool __testeof = traits_type::eq_int_type(__c, __ret); if (!__testeof) { const bool __testeq = traits_type::eq(traits_type:: to_char_type(__c), this->gptr()[-1]); const bool __testout = this->_M_mode & ios_base::out; if (__testeq || __testout) { this->gbump(-1); if (!__testeq) *this->gptr() = traits_type::to_char_type(__c); __ret = __c; } } else { this->gbump(-1); __ret = traits_type::not_eof(__c); } } return __ret; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type basic_stringbuf<_CharT, _Traits, _Alloc>:: overflow(int_type __c) { const bool __testout = this->_M_mode & ios_base::out; if (__builtin_expect(!__testout, false)) return traits_type::eof(); const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof()); if (__builtin_expect(__testeof, false)) return traits_type::not_eof(__c); const __size_type __capacity = _M_string.capacity(); if (size_t(this->epptr() - this->pbase()) < __capacity) { char_type* __base = const_cast(_M_string.data()); _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase()); if (_M_mode & ios_base::in) { const __size_type __nget = this->gptr() - this->eback(); const __size_type __eget = this->egptr() - this->eback(); this->setg(__base, __base + __nget, __base + __eget + 1); } *this->pptr() = traits_type::to_char_type(__c); this->pbump(1); return __c; } const __size_type __max_size = _M_string.max_size(); const bool __testput = this->pptr() < this->epptr(); if (__builtin_expect(!__testput && __capacity == __max_size, false)) return traits_type::eof(); const char_type __conv = traits_type::to_char_type(__c); if (!__testput) { # 133 "/usr/include/c++/15/bits/sstream.tcc" 3 const __size_type __opt_len = std::max(__size_type(2 * __capacity), __size_type(512)); const __size_type __len = std::min(__opt_len, __max_size); __string_type __tmp(_M_string.get_allocator()); __tmp.reserve(__len); if (this->pbase()) __tmp.assign(this->pbase(), this->epptr() - this->pbase()); __tmp.push_back(__conv); _M_string.swap(__tmp); _M_sync(const_cast(_M_string.data()), this->gptr() - this->eback(), this->pptr() - this->pbase()); } else *this->pptr() = __conv; this->pbump(1); return __c; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type basic_stringbuf<_CharT, _Traits, _Alloc>:: underflow() { int_type __ret = traits_type::eof(); const bool __testin = this->_M_mode & ios_base::in; if (__testin) { _M_update_egptr(); if (this->gptr() < this->egptr()) __ret = traits_type::to_int_type(*this->gptr()); } return __ret; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type basic_stringbuf<_CharT, _Traits, _Alloc>:: seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode) { pos_type __ret = pos_type(off_type(-1)); bool __testin = (ios_base::in & this->_M_mode & __mode) != 0; bool __testout = (ios_base::out & this->_M_mode & __mode) != 0; const bool __testboth = __testin && __testout && __way != ios_base::cur; __testin &= !(__mode & ios_base::out); __testout &= !(__mode & ios_base::in); const char_type* __beg = __testin ? this->eback() : this->pbase(); if ((__beg || !__off) && (__testin || __testout || __testboth)) { _M_update_egptr(); off_type __newoffi = __off; off_type __newoffo = __newoffi; if (__way == ios_base::cur) { __newoffi += this->gptr() - __beg; __newoffo += this->pptr() - __beg; } else if (__way == ios_base::end) __newoffo = __newoffi += this->egptr() - __beg; if ((__testin || __testboth) && __newoffi >= 0 && this->egptr() - __beg >= __newoffi) { this->setg(this->eback(), this->eback() + __newoffi, this->egptr()); __ret = pos_type(__newoffi); } if ((__testout || __testboth) && __newoffo >= 0 && this->egptr() - __beg >= __newoffo) { _M_pbump(this->pbase(), this->epptr(), __newoffo); __ret = pos_type(__newoffo); } } return __ret; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type basic_stringbuf<_CharT, _Traits, _Alloc>:: seekpos(pos_type __sp, ios_base::openmode __mode) { pos_type __ret = pos_type(off_type(-1)); const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0; const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0; const char_type* __beg = __testin ? this->eback() : this->pbase(); if ((__beg || !off_type(__sp)) && (__testin || __testout)) { _M_update_egptr(); const off_type __pos(__sp); const bool __testpos = (0 <= __pos && __pos <= this->egptr() - __beg); if (__testpos) { if (__testin) this->setg(this->eback(), this->eback() + __pos, this->egptr()); if (__testout) _M_pbump(this->pbase(), this->epptr(), __pos); __ret = __sp; } } return __ret; } template void basic_stringbuf<_CharT, _Traits, _Alloc>:: _M_sync(char_type* __base, __size_type __i, __size_type __o) { const bool __testin = _M_mode & ios_base::in; const bool __testout = _M_mode & ios_base::out; char_type* __endg = __base + _M_string.size(); char_type* __endp = __base + _M_string.capacity(); if (__base != _M_string.data()) { __endg += __i; __i = 0; __endp = __endg; } if (__testin) this->setg(__base, __base + __i, __endg); if (__testout) { _M_pbump(__base, __endp, __o); if (!__testin) this->setg(__endg, __endg, __endg); } } template void basic_stringbuf<_CharT, _Traits, _Alloc>:: _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off) { this->setp(__pbeg, __pend); while (__off > __gnu_cxx::__numeric_traits::__max) { this->pbump(__gnu_cxx::__numeric_traits::__max); __off -= __gnu_cxx::__numeric_traits::__max; } this->pbump(__off); } extern template class basic_stringbuf; extern template class basic_istringstream; extern template class basic_ostringstream; extern template class basic_stringstream; extern template class basic_stringbuf; extern template class basic_istringstream; extern template class basic_ostringstream; extern template class basic_stringstream; } #pragma GCC diagnostic pop # 1256 "/usr/include/c++/15/sstream" 2 3 # 12 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/StringUtil.h" 2 # 19 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/StringUtil.h" namespace c10 { namespace detail { __attribute__((__visibility__("default"))) std::string StripBasename(const std::string& full_path); __attribute__((__visibility__("default"))) std::string ExcludeFileExtension(const std::string& full_path); struct CompileTimeEmptyString { operator const std::string&() const { static const std::string empty_string_literal; return empty_string_literal; } operator const char*() const { return ""; } }; template struct CanonicalizeStrTypes { using type = const T&; }; template struct CanonicalizeStrTypes { using type = const char*; }; inline std::ostream& _str(std::ostream& ss) { return ss; } template inline std::ostream& _str(std::ostream& ss, const T& t) { ss << t; return ss; } template inline std::ostream& _str(std::ostream& ss, const std::optional& t) { if (t.has_value()) { return _str(ss, t.value()); } ss << "std::nullopt"; return ss; } __attribute__((__visibility__("default"))) std::ostream& _str(std::ostream& ss, const wchar_t* wCStr); __attribute__((__visibility__("default"))) std::ostream& _str(std::ostream& ss, const wchar_t& wChar); __attribute__((__visibility__("default"))) std::ostream& _str(std::ostream& ss, const std::wstring& wString); template <> inline std::ostream& _str( std::ostream& ss, const CompileTimeEmptyString&) { return ss; } template inline std::ostream& _str(std::ostream& ss, const T& t, const Args&... args) { return _str(_str(ss, t), args...); } template struct _str_wrapper final { static std::string call(const Args&... args) { std::ostringstream ss; _str(ss, args...); return ss.str(); } }; template <> struct _str_wrapper final { static const std::string& call(const std::string& str) { return str; } }; template <> struct _str_wrapper final { static const char* call(const char* str) { return str; } }; template <> struct _str_wrapper<> final { static CompileTimeEmptyString call() { return CompileTimeEmptyString(); } }; } template inline decltype(auto) str(const Args&... args) { return detail::_str_wrapper< typename detail::CanonicalizeStrTypes::type...>::call(args...); } template inline std::string Join(const std::string& delimiter, const Container& v) { std::stringstream s; int cnt = static_cast(v.size()) - 1; for (auto i = v.begin(); i != v.end(); ++i, --cnt) { s << (*i) << (cnt ? delimiter : ""); } return std::move(s).str(); } size_t __attribute__((__visibility__("default"))) ReplaceAll(std::string& s, std::string_view from, std::string_view to); struct __attribute__((__visibility__("default"))) SourceLocation { const char* function; const char* file; uint32_t line; }; std::ostream& operator<<(std::ostream& out, const SourceLocation& loc); inline bool isPrint(char s) { return s > 0x1f && s < 0x7f; } inline void printQuotedString(std::ostream& stmt, const std::string_view str) { stmt << "\""; for (auto s : str) { switch (s) { case '\\': stmt << "\\\\"; break; case '\'': stmt << "\\'"; break; case '\"': stmt << "\\\""; break; case '\a': stmt << "\\a"; break; case '\b': stmt << "\\b"; break; case '\f': stmt << "\\f"; break; case '\n': stmt << "\\n"; break; case '\r': stmt << "\\r"; break; case '\t': stmt << "\\t"; break; case '\v': stmt << "\\v"; break; default: if (isPrint(s)) { stmt << s; } else { char buf[4] = "000"; buf[2] += s % 8; s /= 8; buf[1] += s % 8; s /= 8; buf[0] += s; stmt << "\\" << buf; } break; } } stmt << "\""; } } # 9 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" 2 # 21 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" namespace c10 { # 30 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" class __attribute__((__visibility__("default"))) Error : public std::exception { private: std::string msg_; std::vector context_; Backtrace backtrace_; mutable OptimisticLazy what_; std::string what_without_backtrace_; const void* caller_; public: Error(SourceLocation source_location, std::string msg); Error( const char* file, const uint32_t line, const char* condition, const std::string& msg, Backtrace backtrace, const void* caller = nullptr); Error( std::string msg, Backtrace backtrace = nullptr, const void* caller = nullptr); void add_context(std::string msg); const std::string& msg() const { return msg_; } const std::vector& context() const { return context_; } const Backtrace& backtrace() const; const char* what() const noexcept override; const void* caller() const noexcept { return caller_; } virtual const char* what_without_backtrace() const noexcept { return what_without_backtrace_.c_str(); } private: void refresh_what(); std::string compute_what(bool include_backtrace) const; }; class __attribute__((__visibility__("default"))) Warning { public: class __attribute__((__visibility__("default"))) UserWarning {}; class __attribute__((__visibility__("default"))) DeprecationWarning {}; using warning_variant_t = std::variant; Warning( warning_variant_t type, const SourceLocation& source_location, std::string msg, bool verbatim); Warning( warning_variant_t type, SourceLocation source_location, const char* msg, bool verbatim); Warning( warning_variant_t type, SourceLocation source_location, ::c10::detail::CompileTimeEmptyString msg, bool verbatim); warning_variant_t type() const; const SourceLocation& source_location() const; const std::string& msg() const; bool verbatim() const; private: warning_variant_t type_; SourceLocation source_location_; std::string msg_; bool verbatim_; }; using UserWarning = Warning::UserWarning; using DeprecationWarning = Warning::DeprecationWarning; void __attribute__((__visibility__("default"))) warn(const Warning& warning); class __attribute__((__visibility__("default"))) WarningHandler { public: virtual ~WarningHandler() = default; virtual void process(const Warning& warning); }; namespace WarningUtils { # 196 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" __attribute__((__visibility__("default"))) void set_warning_handler(WarningHandler* handler) noexcept(true); __attribute__((__visibility__("default"))) WarningHandler* get_warning_handler() noexcept(true); class __attribute__((__visibility__("default"))) WarningHandlerGuard { WarningHandler* prev_handler_; public: WarningHandlerGuard(WarningHandler* new_handler) : prev_handler_(c10::WarningUtils::get_warning_handler()) { c10::WarningUtils::set_warning_handler(new_handler); } WarningHandlerGuard(WarningHandlerGuard&& other) = delete; WarningHandlerGuard(const WarningHandlerGuard&) = delete; WarningHandlerGuard& operator=(const WarningHandlerGuard&) = delete; WarningHandlerGuard& operator=(WarningHandlerGuard&&) = delete; ~WarningHandlerGuard() { c10::WarningUtils::set_warning_handler(prev_handler_); } }; __attribute__((__visibility__("default"))) void set_warnAlways(bool) noexcept(true); __attribute__((__visibility__("default"))) bool get_warnAlways() noexcept(true); struct __attribute__((__visibility__("default"))) WarnAlways { public: explicit WarnAlways(bool setting = true); ~WarnAlways(); private: bool prev_setting; }; } class __attribute__((__visibility__("default"))) ErrorAlwaysShowCppStacktrace : public Error { using Error::Error; const char* what_without_backtrace() const noexcept override { return what(); } }; class __attribute__((__visibility__("default"))) IndexError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) ValueError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) TypeError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) NotImplementedError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) EnforceFiniteError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) OnnxfiBackendSystemError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) LinAlgError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) OutOfMemoryError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) DistError : public Error { using Error::Error; }; class __attribute__((__visibility__("default"))) DistBackendError : public DistError { using DistError::DistError; }; class __attribute__((__visibility__("default"))) DistStoreError : public DistError { using DistError::DistError; }; class __attribute__((__visibility__("default"))) DistNetworkError : public DistError { using DistError::DistError; }; __attribute__((__visibility__("default"))) std::string GetExceptionString(const std::exception& e); } # 457 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" namespace c10::detail { template decltype(auto) torchCheckMsgImpl(const char* , const Args&... args) { return ::c10::str(args...); } inline __attribute__((__visibility__("default"))) const char* torchCheckMsgImpl(const char* msg) { return msg; } inline __attribute__((__visibility__("default"))) const char* torchCheckMsgImpl( const char* , const char* args) { return args; } } # 486 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" namespace c10::detail { [[noreturn]] __attribute__((__visibility__("default"))) void torchCheckFail( const char* func, const char* file, uint32_t line, const std::string& msg); [[noreturn]] __attribute__((__visibility__("default"))) void torchCheckFail( const char* func, const char* file, uint32_t line, const char* msg); [[noreturn]] __attribute__((__visibility__("default"))) void torchInternalAssertFail( const char* func, const char* file, uint32_t line, const char* condMsg, const char* userMsg); [[noreturn]] inline __attribute__((__visibility__("default"))) void torchInternalAssertFail( const char* func, const char* file, uint32_t line, const char* condMsg, ::c10::detail::CompileTimeEmptyString ) { torchCheckFail(func, file, line, condMsg); } [[noreturn]] __attribute__((__visibility__("default"))) void torchInternalAssertFail( const char* func, const char* file, uint32_t line, const char* condMsg, const std::string& userMsg); } # 692 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" namespace c10::detail { inline void deprecated_AT_ERROR() {} # 709 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" inline void deprecated_AT_ASSERT() {} # 719 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Exception.h" inline void deprecated_AT_ASSERTM() {} } # 21 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 1 # 22 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/AlignOf.h" 1 # 17 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/AlignOf.h" namespace c10 { # 36 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/AlignOf.h" template struct AlignedCharArray { alignas(Alignment) char buffer[Size]; }; # 106 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/AlignOf.h" namespace detail { template < typename T1, typename T2 = char, typename T3 = char, typename T4 = char, typename T5 = char, typename T6 = char, typename T7 = char, typename T8 = char, typename T9 = char, typename T10 = char> class AlignerImpl { T1 t1; T2 t2; T3 t3; T4 t4; T5 t5; T6 t6; T7 t7; T8 t8; T9 t9; T10 t10; public: AlignerImpl() = delete; }; template < typename T1, typename T2 = char, typename T3 = char, typename T4 = char, typename T5 = char, typename T6 = char, typename T7 = char, typename T8 = char, typename T9 = char, typename T10 = char> union SizerImpl { char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)], arr5[sizeof(T5)], arr6[sizeof(T6)], arr7[sizeof(T7)], arr8[sizeof(T8)], arr9[sizeof(T9)], arr10[sizeof(T10)]; }; } # 160 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/AlignOf.h" template < typename T1, typename T2 = char, typename T3 = char, typename T4 = char, typename T5 = char, typename T6 = char, typename T7 = char, typename T8 = char, typename T9 = char, typename T10 = char> struct AlignedCharArrayUnion : AlignedCharArray< alignof(detail::AlignerImpl), sizeof(::c10::detail:: SizerImpl)> {}; } # 26 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 2 # 1 "/usr/include/c++/15/cassert" 1 3 # 46 "/usr/include/c++/15/cassert" 3 # 1 "/usr/include/assert.h" 1 3 4 # 47 "/usr/include/c++/15/cassert" 2 3 # 29 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 2 # 41 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" namespace c10 { # 51 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" template class __attribute__((__visibility__("default"))) SmallVectorBase { protected: void* BeginX; Size_T Size = 0, Capacity; static constexpr size_t SizeTypeMax() { return std::numeric_limits::max(); } SmallVectorBase(void* FirstEl, size_t TotalCapacity) : BeginX(FirstEl), Capacity(TotalCapacity) {} void* mallocForGrow(size_t MinSize, size_t TSize, size_t& NewCapacity); void grow_pod(const void* FirstEl, size_t MinSize, size_t TSize); public: SmallVectorBase() = delete; size_t size() const { return Size; } size_t capacity() const { return Capacity; } [[nodiscard]] bool empty() const { return !Size; } # 97 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" void set_size(size_t N) { # 98 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 98 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; Size = N; } }; template using SmallVectorSizeType = std::conditional_t= 8, uint64_t, uint32_t>; template struct SmallVectorAlignmentAndSize { alignas(SmallVectorBase>) char Base[sizeof( SmallVectorBase>)]; alignas(T) char FirstEl[sizeof(T)]; }; template class SmallVectorTemplateCommon : public SmallVectorBase> { using Base = SmallVectorBase>; void* getFirstEl() const { return const_cast(reinterpret_cast( reinterpret_cast(this) + # 131 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 __builtin_offsetof ( # 131 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" SmallVectorAlignmentAndSize # 131 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 , # 131 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" FirstEl # 131 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 ) # 131 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" )); } protected: SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {} void grow_pod(size_t MinSize, size_t TSize) { Base::grow_pod(getFirstEl(), MinSize, TSize); } bool isSmall() const { return this->BeginX == getFirstEl(); } void resetToSmall() { this->BeginX = getFirstEl(); this->Size = this->Capacity = 0; } bool isReferenceToRange(const void* V, const void* First, const void* Last) const { std::less<> LessThan; return !LessThan(V, First) && LessThan(V, Last); } bool isReferenceToStorage(const void* V) const { return isReferenceToRange(V, this->begin(), this->end()); } bool isRangeInStorage(const void* First, const void* Last) const { std::less<> LessThan; return !LessThan(First, this->begin()) && !LessThan(Last, First) && !LessThan(this->end(), Last); } bool isSafeToReferenceAfterResize(const void* Elt, size_t NewSize) { if ((__builtin_expect(static_cast(!isReferenceToStorage(Elt)), 1))) return true; if (NewSize <= this->size()) return Elt < this->begin() + NewSize; return NewSize <= this->capacity(); } void assertSafeToReferenceAfterResize(const void* Elt, size_t NewSize) { (void)Elt; (void)NewSize; # 195 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 198 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; } void assertSafeToAdd(const void* Elt, size_t N = 1) { this->assertSafeToReferenceAfterResize(Elt, this->size() + N); } void assertSafeToReferenceAfterClear(const T* From, const T* To) { if (From == To) return; this->assertSafeToReferenceAfterResize(From, 0); this->assertSafeToReferenceAfterResize(To - 1, 0); } template < class ItTy, std::enable_if_t, T*>, bool> = false> void assertSafeToReferenceAfterClear(ItTy, ItTy) {} void assertSafeToAddRange(const T* From, const T* To) { if (From == To) return; this->assertSafeToAdd(From, To - From); this->assertSafeToAdd(To - 1, To - From); } template < class ItTy, std::enable_if_t, T*>, bool> = false> void assertSafeToAddRange(ItTy, ItTy) {} template static const T* reserveForParamAndGetAddressImpl( U* This, const T& Elt, size_t N) { size_t NewSize = This->size() + N; if ((__builtin_expect(static_cast(NewSize <= This->capacity()), 1))) return &Elt; bool ReferencesStorage = false; int64_t Index = -1; if constexpr (!U::TakesParamByValue) { if ((__builtin_expect(static_cast(This->isReferenceToStorage(&Elt)), 0))) { ReferencesStorage = true; Index = &Elt - This->begin(); } } This->grow(NewSize); return ReferencesStorage ? This->begin() + Index : &Elt; } public: using size_type = size_t; using difference_type = ptrdiff_t; using value_type = T; using iterator = T*; using const_iterator = const T*; using const_reverse_iterator = std::reverse_iterator; using reverse_iterator = std::reverse_iterator; using reference = T&; using const_reference = const T&; using pointer = T*; using const_pointer = const T*; using Base::capacity; using Base::empty; using Base::size; iterator begin() { return (iterator)this->BeginX; } const_iterator begin() const { return (const_iterator)this->BeginX; } iterator end() { return begin() + size(); } const_iterator end() const { return begin() + size(); } reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } size_type size_in_bytes() const { return size() * sizeof(T); } constexpr size_type max_size() const { return std::min(this->SizeTypeMax(), size_type(-1) / sizeof(T)); } size_t capacity_in_bytes() const { return capacity() * sizeof(T); } pointer data() { return pointer(begin()); } const_pointer data() const { return const_pointer(begin()); } reference at(size_type idx) { # 325 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 325 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return begin()[idx]; } const_reference at(size_type idx) const { # 329 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 329 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return begin()[idx]; } reference operator[](size_type idx) { # 333 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 333 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return begin()[idx]; } const_reference operator[](size_type idx) const { # 337 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 337 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return begin()[idx]; } reference front() { # 342 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 342 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return begin()[0]; } const_reference front() const { # 346 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 346 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return begin()[0]; } reference back() { # 351 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 351 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return end()[-1]; } const_reference back() const { # 355 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 355 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; return end()[-1]; } }; # 371 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" template < typename T, bool = (std::is_trivially_copy_constructible_v)&&( std::is_trivially_move_constructible_v< T>)&&std::is_trivially_destructible_v> class SmallVectorTemplateBase : public SmallVectorTemplateCommon { friend class SmallVectorTemplateCommon; protected: static constexpr bool TakesParamByValue = false; using ValueParamT = const T&; SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon(Size) {} static void destroy_range(T* S, T* E) { while (S != E) { --E; E->~T(); } } template static void uninitialized_move(It1 I, It1 E, It2 Dest) { std::uninitialized_copy( std::make_move_iterator(I), std::make_move_iterator(E), Dest); } template static void uninitialized_copy(It1 I, It1 E, It2 Dest) { std::uninitialized_copy(I, E, Dest); } void grow(size_t MinSize = 0); T* mallocForGrow(size_t MinSize, size_t& NewCapacity) { return static_cast( SmallVectorBase>::mallocForGrow( MinSize, sizeof(T), NewCapacity)); } void moveElementsForGrow(T* NewElts); void takeAllocationForGrow(T* NewElts, size_t NewCapacity); const T* reserveForParamAndGetAddress(const T& Elt, size_t N = 1) { return this->reserveForParamAndGetAddressImpl(this, Elt, N); } T* reserveForParamAndGetAddress(T& Elt, size_t N = 1) { return const_cast(this->reserveForParamAndGetAddressImpl(this, Elt, N)); } static T&& forward_value_param(T&& V) { return std::move(V); } static const T& forward_value_param(const T& V) { return V; } void growAndAssign(size_t NumElts, const T& Elt) { size_t NewCapacity = 0; T* NewElts = mallocForGrow(NumElts, NewCapacity); std::uninitialized_fill_n(NewElts, NumElts, Elt); this->destroy_range(this->begin(), this->end()); takeAllocationForGrow(NewElts, NewCapacity); this->set_size(NumElts); } template T& growAndEmplaceBack(ArgTypes&&... Args) { size_t NewCapacity = 0; T* NewElts = mallocForGrow(0, NewCapacity); ::new ((void*)(NewElts + this->size())) T(std::forward(Args)...); moveElementsForGrow(NewElts); takeAllocationForGrow(NewElts, NewCapacity); this->set_size(this->size() + 1); return this->back(); } public: void push_back(const T& Elt) { const T* EltPtr = reserveForParamAndGetAddress(Elt); ::new ((void*)this->end()) T(*EltPtr); this->set_size(this->size() + 1); } void push_back(T&& Elt) { T* EltPtr = reserveForParamAndGetAddress(Elt); ::new ((void*)this->end()) T(::std::move(*EltPtr)); this->set_size(this->size() + 1); } void pop_back() { this->set_size(this->size() - 1); this->end()->~T(); } }; template void SmallVectorTemplateBase::grow(size_t MinSize) { size_t NewCapacity = 0; T* NewElts = mallocForGrow(MinSize, NewCapacity); moveElementsForGrow(NewElts); takeAllocationForGrow(NewElts, NewCapacity); } template void SmallVectorTemplateBase::moveElementsForGrow( T* NewElts) { this->uninitialized_move(this->begin(), this->end(), NewElts); destroy_range(this->begin(), this->end()); } template void SmallVectorTemplateBase::takeAllocationForGrow( T* NewElts, size_t NewCapacity) { if (!this->isSmall()) free(this->begin()); this->BeginX = NewElts; this->Capacity = NewCapacity; } template class SmallVectorTemplateBase : public SmallVectorTemplateCommon { friend class SmallVectorTemplateCommon; protected: static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void*); using ValueParamT = std::conditional_t; SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon(Size) {} static void destroy_range(T*, T*) {} template static void uninitialized_move(It1 I, It1 E, It2 Dest) { uninitialized_copy(I, E, Dest); } template static void uninitialized_copy(It1 I, It1 E, It2 Dest) { std::uninitialized_copy(I, E, Dest); } template static void uninitialized_copy( T1* I, T1* E, T2* Dest, std::enable_if_t, T2>>* = nullptr) { if (I != E) memcpy(reinterpret_cast(Dest), I, (E - I) * sizeof(T)); } void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); } const T* reserveForParamAndGetAddress(const T& Elt, size_t N = 1) { return this->reserveForParamAndGetAddressImpl(this, Elt, N); } T* reserveForParamAndGetAddress(T& Elt, size_t N = 1) { return const_cast(this->reserveForParamAndGetAddressImpl(this, Elt, N)); } static ValueParamT forward_value_param(ValueParamT V) { return V; } void growAndAssign(size_t NumElts, T Elt) { this->set_size(0); this->grow(NumElts); std::uninitialized_fill_n(this->begin(), NumElts, Elt); this->set_size(NumElts); } template T& growAndEmplaceBack(ArgTypes&&... Args) { push_back(T(std::forward(Args)...)); return this->back(); } public: void push_back(ValueParamT Elt) { const T* EltPtr = reserveForParamAndGetAddress(Elt); memcpy(reinterpret_cast(this->end()), EltPtr, sizeof(T)); this->set_size(this->size() + 1); } void pop_back() { this->set_size(this->size() - 1); } }; template class SmallVectorImpl : public SmallVectorTemplateBase { using SuperClass = SmallVectorTemplateBase; public: using iterator = typename SuperClass::iterator; using const_iterator = typename SuperClass::const_iterator; using reference = typename SuperClass::reference; using size_type = typename SuperClass::size_type; protected: using SmallVectorTemplateBase::TakesParamByValue; using ValueParamT = typename SuperClass::ValueParamT; explicit SmallVectorImpl(unsigned N) : SmallVectorTemplateBase(N) {} public: SmallVectorImpl(const SmallVectorImpl&) = delete; ~SmallVectorImpl() { if (!this->isSmall()) free(this->begin()); } void clear() { this->destroy_range(this->begin(), this->end()); this->Size = 0; } private: template void resizeImpl(size_type N) { if (N < this->size()) { this->pop_back_n(this->size() - N); } else if (N > this->size()) { this->reserve(N); for (auto I = this->end(), E = this->begin() + N; I != E; ++I) if (ForOverwrite) new (&*I) T; else new (&*I) T(); this->set_size(N); } } public: void resize(size_type N) { resizeImpl(N); } void resize_for_overwrite(size_type N) { resizeImpl(N); } void resize(size_type N, ValueParamT NV) { if (N == this->size()) return; if (N < this->size()) { this->pop_back_n(this->size() - N); return; } this->append(N - this->size(), NV); } void reserve(size_type N) { if (this->capacity() < N) this->grow(N); } void pop_back_n(size_type NumItems) { # 708 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 708 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; this->destroy_range(this->end() - NumItems, this->end()); this->set_size(this->size() - NumItems); } [[nodiscard]] T pop_back_val() { T Result = ::std::move(this->back()); this->pop_back(); return Result; } void swap(SmallVectorImpl& RHS) noexcept; template < typename in_iter, typename = std::enable_if_t::iterator_category, std::input_iterator_tag>>> void append(in_iter in_start, in_iter in_end) { this->assertSafeToAddRange(in_start, in_end); size_type NumInputs = std::distance(in_start, in_end); this->reserve(this->size() + NumInputs); this->uninitialized_copy(in_start, in_end, this->end()); this->set_size(this->size() + NumInputs); } void append(size_type NumInputs, ValueParamT Elt) { const T* EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs); std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr); this->set_size(this->size() + NumInputs); } void append(std::initializer_list IL) { append(IL.begin(), IL.end()); } void append(const SmallVectorImpl& RHS) { append(RHS.begin(), RHS.end()); } void assign(size_type NumElts, ValueParamT Elt) { if (NumElts > this->capacity()) { this->growAndAssign(NumElts, Elt); return; } std::fill_n(this->begin(), std::min(NumElts, this->size()), Elt); if (NumElts > this->size()) std::uninitialized_fill_n(this->end(), NumElts - this->size(), Elt); else if (NumElts < this->size()) this->destroy_range(this->begin() + NumElts, this->end()); this->set_size(NumElts); } template < typename in_iter, typename = std::enable_if_t::iterator_category, std::input_iterator_tag>>> void assign(in_iter in_start, in_iter in_end) { this->assertSafeToReferenceAfterClear(in_start, in_end); clear(); append(in_start, in_end); } void assign(std::initializer_list IL) { clear(); append(IL); } void assign(const SmallVectorImpl& RHS) { assign(RHS.begin(), RHS.end()); } iterator erase(iterator I) { # 790 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 791 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; iterator N = I; std::move(I + 1, this->end(), I); this->pop_back(); return (N); } iterator erase(iterator S, iterator E) { # 802 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 802 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; iterator N = S; iterator I = std::move(E, this->end(), S); this->destroy_range(I, this->end()); this->set_size(I - this->begin()); return (N); } private: template iterator insert_one_impl(iterator I, ArgType&& Elt) { static_assert( std::is_same>, T>:: value, "ArgType must be derived from T!"); if (I == this->end()) { this->push_back(::std::forward(Elt)); return this->end() - 1; } # 827 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 829 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; size_t Index = I - this->begin(); std::remove_reference_t* EltPtr = this->reserveForParamAndGetAddress(Elt); I = this->begin() + Index; ::new ((void*)this->end()) T(::std::move(this->back())); std::move_backward(I, this->end() - 1, this->end()); this->set_size(this->size() + 1); static_assert( !TakesParamByValue || std::is_same_v, "ArgType must be 'T' when taking by value!"); if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end())) ++EltPtr; *I = ::std::forward(*EltPtr); return I; } public: iterator insert(iterator I, T&& Elt) { return insert_one_impl(I, this->forward_value_param(std::move(Elt))); } iterator insert(iterator I, const T& Elt) { return insert_one_impl(I, this->forward_value_param(Elt)); } iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) { size_t InsertElt = I - this->begin(); if (I == this->end()) { append(NumToInsert, Elt); return this->begin() + InsertElt; } # 872 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 874 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; const T* EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert); I = this->begin() + InsertElt; if (size_t(this->end() - I) >= NumToInsert) { T* OldEnd = this->end(); append( std::move_iterator(this->end() - NumToInsert), std::move_iterator(this->end())); std::move_backward(I, OldEnd - NumToInsert, OldEnd); if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end()) EltPtr += NumToInsert; std::fill_n(I, NumToInsert, *EltPtr); return I; } T* OldEnd = this->end(); this->set_size(this->size() + NumToInsert); size_t NumOverwritten = OldEnd - I; this->uninitialized_move(I, OldEnd, this->end() - NumOverwritten); if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end()) EltPtr += NumToInsert; std::fill_n(I, NumOverwritten, *EltPtr); std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr); return I; } template < typename ItTy, typename = std::enable_if_t::iterator_category, std::input_iterator_tag>>> iterator insert(iterator I, ItTy From, ItTy To) { size_t InsertElt = I - this->begin(); if (I == this->end()) { append(From, To); return this->begin() + InsertElt; } # 941 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" 3 4 (static_cast (0)) # 943 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" ; this->assertSafeToAddRange(From, To); size_t NumToInsert = std::distance(From, To); reserve(this->size() + NumToInsert); I = this->begin() + InsertElt; if (size_t(this->end() - I) >= NumToInsert) { T* OldEnd = this->end(); append( std::move_iterator(this->end() - NumToInsert), std::move_iterator(this->end())); std::move_backward(I, OldEnd - NumToInsert, OldEnd); std::copy(From, To, I); return I; } T* OldEnd = this->end(); this->set_size(this->size() + NumToInsert); size_t NumOverwritten = OldEnd - I; this->uninitialized_move(I, OldEnd, this->end() - NumOverwritten); for (T* J = I; NumOverwritten > 0; --NumOverwritten) { *J = *From; ++J; ++From; } this->uninitialized_copy(From, To, OldEnd); return I; } void insert(iterator I, std::initializer_list IL) { insert(I, IL.begin(), IL.end()); } template reference emplace_back(ArgTypes&&... Args) { if ((__builtin_expect(static_cast(this->size() >= this->capacity()), 0))) return this->growAndEmplaceBack(std::forward(Args)...); ::new ((void*)this->end()) T(std::forward(Args)...); this->set_size(this->size() + 1); return this->back(); } SmallVectorImpl& operator=(const SmallVectorImpl& RHS); SmallVectorImpl& operator=(SmallVectorImpl&& RHS) noexcept( std::is_nothrow_move_constructible_v && std::is_nothrow_destructible_v); bool operator==(const SmallVectorImpl& RHS) const { if (this->size() != RHS.size()) return false; return std::equal(this->begin(), this->end(), RHS.begin()); } bool operator!=(const SmallVectorImpl& RHS) const { return !(*this == RHS); } bool operator<(const SmallVectorImpl& RHS) const { return std::lexicographical_compare( this->begin(), this->end(), RHS.begin(), RHS.end()); } }; template void SmallVectorImpl::swap(SmallVectorImpl& RHS) noexcept { if (this == &RHS) return; if (!this->isSmall() && !RHS.isSmall()) { std::swap(this->BeginX, RHS.BeginX); std::swap(this->Size, RHS.Size); std::swap(this->Capacity, RHS.Capacity); return; } this->reserve(RHS.size()); RHS.reserve(this->size()); size_t NumShared = this->size(); if (NumShared > RHS.size()) NumShared = RHS.size(); for (size_type i = 0; i != NumShared; ++i) std::swap((*this)[i], RHS[i]); if (this->size() > RHS.size()) { size_t EltDiff = this->size() - RHS.size(); this->uninitialized_copy(this->begin() + NumShared, this->end(), RHS.end()); RHS.set_size(RHS.size() + EltDiff); this->destroy_range(this->begin() + NumShared, this->end()); this->set_size(NumShared); } else if (RHS.size() > this->size()) { size_t EltDiff = RHS.size() - this->size(); this->uninitialized_copy(RHS.begin() + NumShared, RHS.end(), this->end()); this->set_size(this->size() + EltDiff); this->destroy_range(RHS.begin() + NumShared, RHS.end()); RHS.set_size(NumShared); } } template SmallVectorImpl& SmallVectorImpl::operator=( const SmallVectorImpl& RHS) { if (this == &RHS) return *this; size_t RHSSize = RHS.size(); size_t CurSize = this->size(); if (CurSize >= RHSSize) { iterator NewEnd; if (RHSSize) NewEnd = std::copy(RHS.begin(), RHS.begin() + RHSSize, this->begin()); else NewEnd = this->begin(); this->destroy_range(NewEnd, this->end()); this->set_size(RHSSize); return *this; } if (this->capacity() < RHSSize) { this->clear(); CurSize = 0; this->grow(RHSSize); } else if (CurSize) { std::copy(RHS.begin(), RHS.begin() + CurSize, this->begin()); } this->uninitialized_copy( RHS.begin() + CurSize, RHS.end(), this->begin() + CurSize); this->set_size(RHSSize); return *this; } template SmallVectorImpl& SmallVectorImpl:: operator=(SmallVectorImpl&& RHS) noexcept( std::is_nothrow_move_constructible_v && std::is_nothrow_destructible_v) { if (this == &RHS) return *this; if (!RHS.isSmall()) { this->destroy_range(this->begin(), this->end()); if (!this->isSmall()) free(this->begin()); this->BeginX = RHS.BeginX; this->Size = RHS.Size; this->Capacity = RHS.Capacity; RHS.resetToSmall(); return *this; } size_t RHSSize = RHS.size(); size_t CurSize = this->size(); if (CurSize >= RHSSize) { iterator NewEnd = this->begin(); if (RHSSize) NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd); this->destroy_range(NewEnd, this->end()); this->set_size(RHSSize); RHS.clear(); return *this; } if (this->capacity() < RHSSize) { this->clear(); CurSize = 0; this->grow(RHSSize); } else if (CurSize) { std::move(RHS.begin(), RHS.begin() + CurSize, this->begin()); } this->uninitialized_move( RHS.begin() + CurSize, RHS.end(), this->begin() + CurSize); this->set_size(RHSSize); RHS.clear(); return *this; } template struct SmallVectorStorage { alignas(T) char InlineElts[N * sizeof(T)]; }; template struct alignas(T) SmallVectorStorage {}; template class SmallVector; template struct CalculateSmallVectorDefaultInlinedElements { static constexpr size_t kPreferredSmallVectorSizeof = 64; # 1239 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" static_assert( sizeof(T) <= 256, "You are trying to use a default number of inlined elements for " "`SmallVector` but `sizeof(T)` is really big! Please use an " "explicit number of inlined elements with `SmallVector` to make " "sure you really want that much inline storage."); static constexpr size_t PreferredInlineBytes = kPreferredSmallVectorSizeof - sizeof(SmallVector); static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T); static constexpr size_t value = NumElementsThatFit == 0 ? 1 : NumElementsThatFit; }; # 1271 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/SmallVector.h" template < typename T, unsigned N = CalculateSmallVectorDefaultInlinedElements::value> class SmallVector : public SmallVectorImpl, SmallVectorStorage { public: SmallVector() : SmallVectorImpl(N) {} ~SmallVector() { this->destroy_range(this->begin(), this->end()); } explicit SmallVector(size_t Size, const T& Value = T()) : SmallVectorImpl(N) { this->assign(Size, Value); } template < typename ItTy, typename = std::enable_if_t::iterator_category, std::input_iterator_tag>>> SmallVector(ItTy S, ItTy E) : SmallVectorImpl(N) { this->append(S, E); } template < typename Container, std::enable_if_t< std::is_convertible_v< typename std::iterator_traits< decltype(std::declval() .begin())>::iterator_category, std::input_iterator_tag> && std::is_convertible_v< typename std::iterator_traits< decltype(std::declval() .end())>::iterator_category, std::input_iterator_tag>, int> = 0> explicit SmallVector(Container&& c) : SmallVectorImpl(N) { this->append(c.begin(), c.end()); } SmallVector(std::initializer_list IL) : SmallVectorImpl(N) { this->assign(IL); } SmallVector(const SmallVector& RHS) : SmallVectorImpl(N) { if (!RHS.empty()) SmallVectorImpl::operator=(RHS); } SmallVector& operator=(const SmallVector& RHS) { SmallVectorImpl::operator=(RHS); return *this; } SmallVector(SmallVector&& RHS) noexcept( std::is_nothrow_move_assignable_v>) : SmallVectorImpl(N) { if (!RHS.empty()) SmallVectorImpl::operator=(::std::move(RHS)); } template < typename Container, std::enable_if_t< std::is_convertible_v< typename std::iterator_traits< decltype(std::declval() .begin())>::iterator_category, std::input_iterator_tag> && std::is_convertible_v< typename std::iterator_traits< decltype(std::declval() .end())>::iterator_category, std::input_iterator_tag>, int> = 0> SmallVector& operator=(const Container& RHS) { this->assign(RHS.begin(), RHS.end()); return *this; } SmallVector(SmallVectorImpl&& RHS) noexcept( std::is_nothrow_move_assignable_v>) : SmallVectorImpl(N) { if (!RHS.empty()) SmallVectorImpl::operator=(::std::move(RHS)); } SmallVector& operator=(SmallVector&& RHS) noexcept( std::is_nothrow_move_assignable_v>) { SmallVectorImpl::operator=(::std::move(RHS)); return *this; } SmallVector& operator=(SmallVectorImpl&& RHS) noexcept( std::is_nothrow_move_constructible_v>) { SmallVectorImpl::operator=(::std::move(RHS)); return *this; } template < typename Container, std::enable_if_t< std::is_convertible_v< typename std::iterator_traits< decltype(std::declval() .begin())>::iterator_category, std::input_iterator_tag> && std::is_convertible_v< typename std::iterator_traits< decltype(std::declval() .end())>::iterator_category, std::input_iterator_tag>, int> = 0> SmallVector& operator=(Container&& C) { this->assign(C.begin(), C.end()); return *this; } SmallVector& operator=(std::initializer_list IL) { this->assign(IL); return *this; } }; template inline size_t capacity_in_bytes(const SmallVector& X) { return X.capacity_in_bytes(); } template std::ostream& operator<<(std::ostream& out, const SmallVector& list) { int i = 0; out << "["; for (auto e : list) { if (i++ > 0) out << ", "; out << e; } out << "]"; return out; } template using ValueTypeFromRangeType = std::remove_const_t< std::remove_reference_t()))>>; template SmallVector, Size> to_vector(R&& Range) { return {std::begin(Range), std::end(Range)}; } template SmallVector< ValueTypeFromRangeType, CalculateSmallVectorDefaultInlinedElements< ValueTypeFromRangeType>::value> to_vector(R&& Range) { return {std::begin(Range), std::end(Range)}; } } namespace std { template inline void swap( c10::SmallVectorImpl& LHS, c10::SmallVectorImpl& RHS) noexcept { LHS.swap(RHS); } template inline void swap( c10::SmallVector& LHS, c10::SmallVector& RHS) noexcept { LHS.swap(RHS); } } # 22 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" 2 # 32 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" namespace c10 { # 44 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/ArrayRef.h" template class ArrayRef final { public: using iterator = const T*; using const_iterator = const T*; using size_type = size_t; using value_type = T; using reverse_iterator = std::reverse_iterator; private: const T* Data; size_type Length; void debugCheckNullptrInvariant() { while (false) if ((__builtin_expect(static_cast(!(Data != nullptr || Length == 0)), 0))) { ::c10::detail::torchInternalAssertFail( __func__, "./c10/util/ArrayRef.h", static_cast(62), "Data != nullptr || Length == 0" " INTERNAL ASSERT FAILED at " "\"./c10/util/ArrayRef.h\"" ":" "62" ", please report a bug to PyTorch. ", c10::str("created ArrayRef with nullptr and non-zero length! std::optional relies on this being illegal")); } ; } public: constexpr ArrayRef() : Data(nullptr), Length(0) {} constexpr ArrayRef(const T& OneElt) : Data(&OneElt), Length(1) {} constexpr ArrayRef(const T* data, size_t length) : Data(data), Length(length) { debugCheckNullptrInvariant(); } constexpr ArrayRef(const T* begin, const T* end) : Data(begin), Length(end - begin) { debugCheckNullptrInvariant(); } template ArrayRef(const SmallVectorTemplateCommon& Vec) : Data(Vec.data()), Length(Vec.size()) { debugCheckNullptrInvariant(); } template < typename Container, typename U = decltype(std::declval().data()), typename = std::enable_if_t< (std::is_same_v || std::is_same_v)>> ArrayRef(const Container& container) : Data(container.data()), Length(container.size()) { debugCheckNullptrInvariant(); } template ArrayRef(const std::vector& Vec) : Data(Vec.data()), Length(Vec.size()) { static_assert( !std::is_same_v, "ArrayRef cannot be constructed from a std::vector bitfield."); } template constexpr ArrayRef(const std::array& Arr) : Data(Arr.data()), Length(N) {} template constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {} constexpr ArrayRef(const std::initializer_list& Vec) : Data( std::begin(Vec) == std::end(Vec) ? static_cast(nullptr) : std::begin(Vec)), Length(Vec.size()) {} constexpr iterator begin() const { return Data; } constexpr iterator end() const { return Data + Length; } constexpr const_iterator cbegin() const { return Data; } constexpr const_iterator cend() const { return Data + Length; } constexpr reverse_iterator rbegin() const { return reverse_iterator(end()); } constexpr reverse_iterator rend() const { return reverse_iterator(begin()); } constexpr bool allMatch(const std::function& pred) const { return std::all_of(cbegin(), cend(), pred); } constexpr bool empty() const { return Length == 0; } constexpr const T* data() const { return Data; } constexpr size_t size() const { return Length; } constexpr const T& front() const { if ((__builtin_expect(static_cast(!(!empty())), 0))) { ::c10::detail::torchCheckFail( __func__, "./c10/util/ArrayRef.h", static_cast(186), (::c10::detail::torchCheckMsgImpl( "Expected " "!empty()" " to be true, but got false. " "(Could this error message be improved? If so, " "please report an enhancement request to PyTorch.)", "ArrayRef: attempted to access front() of empty list"))); } ; return Data[0]; } constexpr const T& back() const { if ((__builtin_expect(static_cast(!(!empty())), 0))) { ::c10::detail::torchCheckFail( __func__, "./c10/util/ArrayRef.h", static_cast(193), (::c10::detail::torchCheckMsgImpl( "Expected " "!empty()" " to be true, but got false. " "(Could this error message be improved? If so, " "please report an enhancement request to PyTorch.)", "ArrayRef: attempted to access back() of empty list"))); }; return Data[Length - 1]; } constexpr bool equals(ArrayRef RHS) const { return Length == RHS.Length && std::equal(begin(), end(), RHS.begin()); } constexpr ArrayRef slice(size_t N, size_t M) const { if ((__builtin_expect(static_cast(!(N + M <= size())), 0))) { ::c10::detail::torchCheckFail( __func__, "./c10/util/ArrayRef.h", static_cast(204), (::c10::detail::torchCheckMsgImpl( "Expected " "N + M <= size()" " to be true, but got false. " "(Could this error message be improved? If so, " "please report an enhancement request to PyTorch.)", "ArrayRef: invalid slice, N = ", N, "; M = ", M, "; size = ", size()))); } ; return ArrayRef(data() + N, M); } constexpr ArrayRef slice(size_t N) const { if ((__builtin_expect(static_cast(!(N <= size())), 0))) { ::c10::detail::torchCheckFail( __func__, "./c10/util/ArrayRef.h", static_cast(217), (::c10::detail::torchCheckMsgImpl( "Expected " "N <= size()" " to be true, but got false. " "(Could this error message be improved? If so, " "please report an enhancement request to PyTorch.)", "ArrayRef: invalid slice, N = ", N, "; size = ", size()))); } ; return slice(N, size() - N); } constexpr const T& operator[](size_t Index) const { return Data[Index]; } constexpr const T& at(size_t Index) const { if ((__builtin_expect(static_cast(!(Index < Length)), 0))) { ::c10::detail::torchCheckFail( __func__, "./c10/util/ArrayRef.h", static_cast(231), (::c10::detail::torchCheckMsgImpl( "Expected " "Index < Length" " to be true, but got false. " "(Could this error message be improved? If so, " "please report an enhancement request to PyTorch.)", "ArrayRef: invalid index Index = ", Index, "; Length = ", Length))); } ; return Data[Index]; } template std::enable_if_t, ArrayRef>& operator=( U&& Temporary) = delete; template std::enable_if_t, ArrayRef>& operator=( std::initializer_list) = delete; std::vector vec() const { return std::vector(Data, Data + Length); } }; template std::ostream& operator<<(std::ostream& out, ArrayRef list) { int i = 0; out << "["; for (const auto& e : list) { if (i++ > 0) out << ", "; out << e; } out << "]"; return out; } template ArrayRef makeArrayRef(const T& OneElt) { return OneElt; } template ArrayRef makeArrayRef(const T* data, size_t length) { return ArrayRef(data, length); } template ArrayRef makeArrayRef(const T* begin, const T* end) { return ArrayRef(begin, end); } template ArrayRef makeArrayRef(const SmallVectorImpl& Vec) { return Vec; } template ArrayRef makeArrayRef(const SmallVector& Vec) { return Vec; } template ArrayRef makeArrayRef(const std::vector& Vec) { return Vec; } template ArrayRef makeArrayRef(const std::array& Arr) { return Arr; } template ArrayRef makeArrayRef(const ArrayRef& Vec) { return Vec; } template ArrayRef& makeArrayRef(ArrayRef& Vec) { return Vec; } template ArrayRef makeArrayRef(const T (&Arr)[N]) { return ArrayRef(Arr); } template bool operator==(c10::ArrayRef a1, c10::ArrayRef a2) { return a1.equals(a2); } template bool operator!=(c10::ArrayRef a1, c10::ArrayRef a2) { return !a1.equals(a2); } template bool operator==(const std::vector& a1, c10::ArrayRef a2) { return c10::ArrayRef(a1).equals(a2); } template bool operator!=(const std::vector& a1, c10::ArrayRef a2) { return !c10::ArrayRef(a1).equals(a2); } template bool operator==(c10::ArrayRef a1, const std::vector& a2) { return a1.equals(c10::ArrayRef(a2)); } template bool operator!=(c10::ArrayRef a1, const std::vector& a2) { return !a1.equals(c10::ArrayRef(a2)); } using IntArrayRef = ArrayRef; using IntList [[deprecated]] = ArrayRef; } # 5 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.h" 2 namespace at { class Tensor; namespace native { using convolution_depthwise3x3_winograd_fn = Tensor (*)(const Tensor &, const Tensor &, const Tensor &, IntArrayRef, IntArrayRef, int64_t); struct convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type : DispatchStub { convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type() = default; convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type(const convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type&) = delete; convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type& operator=(const convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type&) = delete; convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type(convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type&&) = delete; convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type& operator=(convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type&&) = delete; ~convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type() = default; }; extern __attribute__((__visibility__("default"))) struct convolution_depthwise3x3_winograd_stub_DECLARE_DISPATCH_type convolution_depthwise3x3_winograd_stub; } } # 3 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/native/cpu/DepthwiseConvKernel.cpp" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/aten/src/ATen/core/Tensor.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/core/TensorBody.h" 1 # 11 "/build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/core/TensorBody.h" # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Device.h" 1 # 13 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Device.h" namespace c10 { using DeviceIndex = int8_t; # 31 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Device.h" struct __attribute__((__visibility__("default"))) Device final { using Type = DeviceType; Device(DeviceType type, DeviceIndex index = -1) : type_(type), index_(index) { validate(); } Device(const std::string& device_string); bool operator==(const Device& other) const noexcept { return this->type_ == other.type_ && this->index_ == other.index_; } bool operator!=(const Device& other) const noexcept { return !(*this == other); } void set_index(DeviceIndex index) { index_ = index; } DeviceType type() const noexcept { return type_; } DeviceIndex index() const noexcept { return index_; } bool has_index() const noexcept { return index_ != -1; } bool is_cuda() const noexcept { return type_ == DeviceType::CUDA; } bool is_privateuseone() const noexcept { return type_ == DeviceType::PrivateUse1; } bool is_mps() const noexcept { return type_ == DeviceType::MPS; } bool is_hip() const noexcept { return type_ == DeviceType::HIP; } bool is_ve() const noexcept { return type_ == DeviceType::VE; } bool is_xpu() const noexcept { return type_ == DeviceType::XPU; } bool is_ipu() const noexcept { return type_ == DeviceType::IPU; } bool is_xla() const noexcept { return type_ == DeviceType::XLA; } bool is_mtia() const noexcept { return type_ == DeviceType::MTIA; } bool is_hpu() const noexcept { return type_ == DeviceType::HPU; } bool is_lazy() const noexcept { return type_ == DeviceType::Lazy; } bool is_vulkan() const noexcept { return type_ == DeviceType::Vulkan; } bool is_metal() const noexcept { return type_ == DeviceType::Metal; } bool is_maia() const noexcept { return type_ == DeviceType::MAIA; } bool is_meta() const noexcept { return type_ == DeviceType::Meta; } bool is_cpu() const noexcept { return type_ == DeviceType::CPU; } bool supports_as_strided() const noexcept { return type_ != DeviceType::IPU && type_ != DeviceType::XLA && type_ != DeviceType::Lazy && type_ != DeviceType::MTIA; } std::string str() const; private: DeviceType type_; DeviceIndex index_ = -1; void validate() { while (false) if ((__builtin_expect(static_cast(!(index_ >= -1)), 0))) { ::c10::detail::torchInternalAssertFail( __func__, "./c10/core/Device.h", static_cast(177), "index_ >= -1" " INTERNAL ASSERT FAILED at " "\"./c10/core/Device.h\"" ":" "177" ", please report a bug to PyTorch. ", c10::str("Device index must be -1 or non-negative, got ", static_cast(index_))); } ; while (false) if ((__builtin_expect(static_cast(!(!is_cpu() || index_ <= 0)), 0))) { ::c10::detail::torchInternalAssertFail( __func__, "./c10/core/Device.h", static_cast(181), "!is_cpu() || index_ <= 0" " INTERNAL ASSERT FAILED at " "\"./c10/core/Device.h\"" ":" "181" ", please report a bug to PyTorch. ", c10::str("CPU device index must be -1 or zero, got ", static_cast(index_))); } ; } }; __attribute__((__visibility__("default"))) std::ostream& operator<<(std::ostream& stream, const Device& device); } namespace std { template <> struct hash { size_t operator()(c10::Device d) const noexcept { static_assert(sizeof(c10::DeviceType) == 1, "DeviceType is not 8-bit"); static_assert(sizeof(c10::DeviceIndex) == 1, "DeviceIndex is not 8-bit"); # 210 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Device.h" uint32_t bits = static_cast(static_cast(d.type())) << 16 | static_cast(static_cast(d.index())); return std::hash{}(bits); } }; } # 12 "/build/reproducible-path/pytorch-2.6.0+dfsg/build/aten/src/ATen/core/TensorBody.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Layout.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Backend.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" 1 # 11 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" namespace c10 { # 64 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" enum class BackendComponent : uint8_t { # 94 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" InvalidBit = 0, CPUBit, CUDABit, HIPBit, XLABit, MPSBit, IPUBit, XPUBit, HPUBit, VEBit, LazyBit, MTIABit, PrivateUse1Bit, PrivateUse2Bit, PrivateUse3Bit, MetaBit, EndOfBackendKeys = MetaBit, }; # 135 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" enum class DispatchKey : uint16_t { # 148 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" Undefined = 0, CatchAll = Undefined, # 169 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" Dense, # 180 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" FPGA, MAIA, Vulkan, Metal, Quantized, # 205 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" CustomRNGKeyId, MkldnnCPU, Sparse, SparseCsr, NestedTensor, BackendSelect, Python, Fake, FuncTorchDynamicLayerBackMode, Functionalize, # 261 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" Named, Conjugate, Negative, ZeroTensor, # 310 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" ADInplaceOrView, # 336 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" AutogradOther, AutogradFunctionality, # 348 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" AutogradNestedTensor, Tracer, AutocastCPU, AutocastXPU, AutocastIPU, AutocastHPU, AutocastXLA, AutocastMPS, AutocastCUDA, AutocastPrivateUse1, FuncTorchBatched, BatchedNestedTensor, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, DeferredInit, PythonTLSSnapshot, FuncTorchDynamicLayerFrontMode, TESTING_ONLY_GenericWrapper, # 415 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" TESTING_ONLY_GenericMode, PreDispatch, PythonDispatcher, EndOfFunctionalityKeys, # 442 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" StartOfDenseBackends, CPU, CUDA, HIP, XLA, MPS, IPU, XPU, HPU, VE, Lazy, MTIA, PrivateUse1, PrivateUse2, PrivateUse3, Meta, EndOfDenseBackends = Meta, StartOfQuantizedBackends, QuantizedCPU, QuantizedCUDA, QuantizedHIP, QuantizedXLA, QuantizedMPS, QuantizedIPU, QuantizedXPU, QuantizedHPU, QuantizedVE, QuantizedLazy, QuantizedMTIA, QuantizedPrivateUse1, QuantizedPrivateUse2, QuantizedPrivateUse3, QuantizedMeta, EndOfQuantizedBackends = QuantizedMeta, StartOfSparseBackends, SparseCPU, SparseCUDA, SparseHIP, SparseXLA, SparseMPS, SparseIPU, SparseXPU, SparseHPU, SparseVE, SparseLazy, SparseMTIA, SparsePrivateUse1, SparsePrivateUse2, SparsePrivateUse3, SparseMeta, EndOfSparseBackends = SparseMeta, StartOfSparseCsrBackends, SparseCsrCPU, SparseCsrCUDA, SparseCsrHIP, SparseCsrXLA, SparseCsrMPS, SparseCsrIPU, SparseCsrXPU, SparseCsrHPU, SparseCsrVE, SparseCsrLazy, SparseCsrMTIA, SparseCsrPrivateUse1, SparseCsrPrivateUse2, SparseCsrPrivateUse3, SparseCsrMeta, EndOfSparseCsrBackends = SparseCsrMeta, StartOfNestedTensorBackends, NestedTensorCPU, NestedTensorCUDA, NestedTensorHIP, NestedTensorXLA, NestedTensorMPS, NestedTensorIPU, NestedTensorXPU, NestedTensorHPU, NestedTensorVE, NestedTensorLazy, NestedTensorMTIA, NestedTensorPrivateUse1, NestedTensorPrivateUse2, NestedTensorPrivateUse3, NestedTensorMeta, EndOfNestedTensorBackends = NestedTensorMeta, StartOfAutogradFunctionalityBackends, AutogradCPU, AutogradCUDA, AutogradHIP, AutogradXLA, AutogradMPS, AutogradIPU, AutogradXPU, AutogradHPU, AutogradVE, AutogradLazy, AutogradMTIA, AutogradPrivateUse1, AutogradPrivateUse2, AutogradPrivateUse3, AutogradMeta, EndOfAutogradFunctionalityBackends = AutogradMeta, EndOfRuntimeBackendKeys = EndOfAutogradFunctionalityBackends, # 462 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" Autograd, CompositeImplicitAutograd, FuncTorchBatchedDecomposition, CompositeImplicitAutogradNestedTensor, CompositeExplicitAutograd, CompositeExplicitAutogradNonFunctional, StartOfAliasKeys = Autograd, EndOfAliasKeys = CompositeExplicitAutogradNonFunctional, CPUTensorId = CPU, CUDATensorId = CUDA, DefaultBackend = CompositeExplicitAutograd, PrivateUse1_PreAutograd = AutogradPrivateUse1, PrivateUse2_PreAutograd = AutogradPrivateUse2, PrivateUse3_PreAutograd = AutogradPrivateUse3, Autocast = AutocastCUDA, }; # 523 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" static_assert( (static_cast(BackendComponent::EndOfBackendKeys) + static_cast(DispatchKey::EndOfFunctionalityKeys)) <= 64, "The BackendComponent and DispatchKey enums (below EndOfFunctionalityKeys)" " both map to backend and functionality bits" " into a 64-bit bitmask; you must have less than 64 total entries between them"); constexpr bool isAliasDispatchKey(DispatchKey k) { return k >= DispatchKey::StartOfAliasKeys && k <= DispatchKey::EndOfAliasKeys; } # 547 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKey.h" constexpr bool isPerBackendFunctionalityKey(DispatchKey k) { if (k == DispatchKey::Dense || k == DispatchKey::Quantized || k == DispatchKey::Sparse || k == DispatchKey::SparseCsr || k == DispatchKey::AutogradFunctionality || k == DispatchKey::NestedTensor) { return true; } else { return false; } } constexpr uint8_t num_functionality_keys = static_cast(DispatchKey::EndOfFunctionalityKeys); constexpr uint8_t num_backends = static_cast(BackendComponent::EndOfBackendKeys); static_assert( static_cast(BackendComponent::EndOfBackendKeys) <= 16, "BackendComponent currently only supports <= 16 backends. If we really need to extend this, there are a few places where this invariant is baked in"); constexpr uint8_t numPerBackendFunctionalityKeys() { uint8_t count = 0; for (uint8_t k = 0; k <= num_functionality_keys; ++k) { if (isPerBackendFunctionalityKey(static_cast(k))) ++count; } return count; } constexpr uint16_t num_runtime_entries = num_functionality_keys + (numPerBackendFunctionalityKeys() * (num_backends - 1)); constexpr uint16_t full_backend_mask = (static_cast(1) << num_backends) - 1; __attribute__((__visibility__("default"))) const char* toString(DispatchKey); __attribute__((__visibility__("default"))) const char* toString(BackendComponent); __attribute__((__visibility__("default"))) std::ostream& operator<<(std::ostream&, DispatchKey); __attribute__((__visibility__("default"))) std::ostream& operator<<(std::ostream&, BackendComponent); __attribute__((__visibility__("default"))) DispatchKey getAutogradKeyFromBackend(BackendComponent k); __attribute__((__visibility__("default"))) c10::DispatchKey parseDispatchKey(const std::string& k); constexpr DispatchKey kAutograd = DispatchKey::Autograd; constexpr BackendComponent toBackendComponent(DispatchKey k) { if (k >= DispatchKey::StartOfDenseBackends && k <= DispatchKey::EndOfDenseBackends) { return static_cast( static_cast(k) - static_cast(DispatchKey::StartOfDenseBackends)); } else if ( k >= DispatchKey::StartOfQuantizedBackends && k <= DispatchKey::EndOfQuantizedBackends) { return static_cast( static_cast(k) - static_cast(DispatchKey::StartOfQuantizedBackends)); } else if ( k >= DispatchKey::StartOfSparseBackends && k <= DispatchKey::EndOfSparseBackends) { return static_cast( static_cast(k) - static_cast(DispatchKey::StartOfSparseBackends)); } else if ( k >= DispatchKey::StartOfSparseCsrBackends && k <= DispatchKey::EndOfSparseCsrBackends) { return static_cast( static_cast(k) - static_cast(DispatchKey::StartOfSparseCsrBackends)); } else if ( k >= DispatchKey::StartOfNestedTensorBackends && k <= DispatchKey::EndOfNestedTensorBackends) { return static_cast( static_cast(k) - static_cast(DispatchKey::StartOfNestedTensorBackends)); } else if ( k >= DispatchKey::StartOfAutogradFunctionalityBackends && k <= DispatchKey::EndOfAutogradFunctionalityBackends) { return static_cast( static_cast(k) - static_cast( DispatchKey::StartOfAutogradFunctionalityBackends)); } else { return BackendComponent::InvalidBit; } } constexpr DispatchKey toFunctionalityKey(DispatchKey k) { if (k <= DispatchKey::EndOfFunctionalityKeys) { return k; } else if (k <= DispatchKey::EndOfDenseBackends) { return DispatchKey::Dense; } else if (k <= DispatchKey::EndOfQuantizedBackends) { return DispatchKey::Quantized; } else if (k <= DispatchKey::EndOfSparseBackends) { return DispatchKey::Sparse; } else if (k <= DispatchKey::EndOfSparseCsrBackends) { return DispatchKey::SparseCsr; } else if (k <= DispatchKey::EndOfNestedTensorBackends) { return DispatchKey::NestedTensor; } else if (k <= DispatchKey::EndOfAutogradFunctionalityBackends) { return DispatchKey::AutogradFunctionality; } else { return DispatchKey::Undefined; } } BackendComponent toBackendComponent(DeviceType device_type); constexpr DispatchKey toRuntimePerBackendFunctionalityKey( DispatchKey functionality_k, BackendComponent backend_k) { if (functionality_k == DispatchKey::Dense) { return static_cast( static_cast(DispatchKey::StartOfDenseBackends) + static_cast(backend_k)); } if (functionality_k == DispatchKey::Sparse) { return static_cast( static_cast(DispatchKey::StartOfSparseBackends) + static_cast(backend_k)); } if (functionality_k == DispatchKey::SparseCsr) { return static_cast( static_cast(DispatchKey::StartOfSparseCsrBackends) + static_cast(backend_k)); } if (functionality_k == DispatchKey::Quantized) { return static_cast( static_cast(DispatchKey::StartOfQuantizedBackends) + static_cast(backend_k)); } if (functionality_k == DispatchKey::NestedTensor) { return static_cast( static_cast(DispatchKey::StartOfNestedTensorBackends) + static_cast(backend_k)); } if (functionality_k == DispatchKey::AutogradFunctionality) { return static_cast( static_cast( DispatchKey::StartOfAutogradFunctionalityBackends) + static_cast(backend_k)); } return DispatchKey::Undefined; } } namespace torch { using c10::kAutograd; } namespace std { template <> struct hash { typedef size_t result_type; typedef c10::DispatchKey argument_type; size_t operator()(c10::DispatchKey x) const { return static_cast(x); } }; } # 5 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/Backend.h" 2 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/core/DispatchKeySet.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/Metaprogramming.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/TypeList.h" 1 # 1 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/TypeTraits.h" 1 namespace c10::guts { template struct is_equality_comparable : std::false_type {}; template struct is_equality_comparable< T, std::void_t() == std::declval())>> : std::true_type {}; template using is_equality_comparable_t = typename is_equality_comparable::type; template struct is_hashable : std::false_type {}; template struct is_hashable()(std::declval()))>> : std::true_type {}; template using is_hashable_t = typename is_hashable::type; template struct is_function_type : std::false_type {}; template struct is_function_type : std::true_type {}; template using is_function_type_t = typename is_function_type::type; # 51 "/build/reproducible-path/pytorch-2.6.0+dfsg/c10/util/TypeTraits.h" template